PoolingMemoryManager (Hazelcast Enterprise Native Memory 3.12.12 API)

java.lang.Object
- com.hazelcast.memory.PoolingMemoryManager

All Implemented Interfaces:

com.hazelcast.internal.memory.MemoryAllocator, com.hazelcast.internal.metrics.MetricsProvider, GarbageCollectable, HazelcastMemoryManager, com.hazelcast.nio.Disposable
```
public class PoolingMemoryManager
extends Object
implements HazelcastMemoryManager, GarbageCollectable, com.hazelcast.internal.metrics.MetricsProvider
```
Implements a hierachical memory allocation scheme:
1. Tier-1 is the platform-native memory allocator. It is used to allocate pages managed by Tier-2. Also, larger blocks will be allocated directly from this tier. Size of the page is configurable and the default is 4194304 bytes.
2. Tier-2 is the custom allocator which manages memory within the pages using the buddy allocation policy. Size of the allocated blocks is always of a power of two and the base address of each block is 8-byte aligned. The size of the smallest block that will be allocated is configurable (but never below 8 bytes) and the default is 16 bytes. The client can request to allocate a block of any size; this will result in the allocation of the next-larger power-of-two block which will be only partially utilized by the client (resulting in internal memory fragmentation).
This class is only the top-level coordinator of actual memory managers, which come in two flavors:
1. Thread-local: allocates pages for exclusive use within a single thread. Eliminates the issue of concurrent contention on allocation/deallocation methods, but prevents the transfer of block ownership to another thread. A block must be freed by the thread that allocated it.
2. Global: serves allocation requests done on any thread which was not previously registered for thread-local allocation. Concurrent requests will have to contend for access, hurting performance.
Which manager will serve a particular request is decided internally by this class: if the current thread was previously registered with this manager by calling registerThread(Thread), the thread-local manager dedicated to that thread will be looked up (or created); otherwise the request will be forwarded to the global manager.

Field Summary
- Fields inherited from interface com.hazelcast.memory.HazelcastMemoryManager
  SIZE_INVALID
- Fields inherited from interface com.hazelcast.internal.memory.MemoryAllocator
  NULL_ADDRESS

Constructor Summary

Constructors
Constructor and Description
`PoolingMemoryManager(com.hazelcast.memory.MemorySize cap)`
`PoolingMemoryManager(com.hazelcast.memory.MemorySize size, int minBlockSize, int pageSize)`
`PoolingMemoryManager(com.hazelcast.memory.MemorySize size, int minBlockSize, int pageSize, float metadataSpacePercentage)`
`PoolingMemoryManager(com.hazelcast.memory.MemorySize cap, int minBlockSize, int pageSize, float metadataSpacePercentage, FreeMemoryChecker freeMemoryChecker)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`allocate(long size)` Allocates memory from an internal memory pool or falls back to OS if not enough memory available in pool.
`void`	`compact()` Compacts the memory region.
`void`	`deregisterThread(Thread thread)`
`void`	`dispose()`
`void`	`free(long address, long size)` Gives allocated memory block back to internal pool or to OS if pool is over capacity.
`void`	`gc()`
`long`	`getAllocatedSize(long address)` Returns allocated size of memory block as if it belongs to and is allocated by this memory manager.
`com.hazelcast.memory.GlobalPoolingMemoryManager`	`getGlobalMemoryManager()`
`int`	`getHeaderSize()`
`HazelcastMemoryManager`	`getMemoryManager()`
`com.hazelcast.memory.MemoryStats`	`getMemoryStats()`
`com.hazelcast.internal.memory.MemoryAllocator`	`getSystemAllocator()`
`long`	`getUsableSize(long address)` Returns size of memory block as if it belongs to and is allocated by this memory manager.
`boolean`	`isDisposed()` Gets the disposed state of this memory manager.
`long`	`newSequence()` Creates a new sequence.
`protected ThreadLocalPoolingMemoryManager`	`newThreadLocalPoolingMemoryManager(int minBlockSize, int pageSize, LibMalloc malloc, PooledNativeMemoryStats stats)`
`void`	`provideMetrics(com.hazelcast.internal.metrics.MetricsRegistry registry)`
`long`	`reallocate(long address, long currentSize, long newSize)`
`void`	`registerThread(Thread thread)`
`String`	`toString()`
`long`	`validateAndGetAllocatedSize(long address)` Returns allocated size of memory block if and only if it belongs to and is allocated by this memory manager.
`long`	`validateAndGetUsableSize(long address)` Returns size of memory block if and only if it belongs to and is allocated by this memory manager.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - PoolingMemoryManager
```
public PoolingMemoryManager(com.hazelcast.memory.MemorySize cap)
```
  - PoolingMemoryManager
```
public PoolingMemoryManager(com.hazelcast.memory.MemorySize size,
                            int minBlockSize,
                            int pageSize)
```
  - PoolingMemoryManager
```
public PoolingMemoryManager(com.hazelcast.memory.MemorySize size,
                            int minBlockSize,
                            int pageSize,
                            float metadataSpacePercentage)
```
  - PoolingMemoryManager
```
public PoolingMemoryManager(com.hazelcast.memory.MemorySize cap,
                            int minBlockSize,
                            int pageSize,
                            float metadataSpacePercentage,
                            FreeMemoryChecker freeMemoryChecker)
```
- Method Detail
  - allocate
```
public long allocate(long size)
```
    Allocates memory from an internal memory pool or falls back to OS if not enough memory available in pool. Content of the memory block will be initialized to zero.
    Complement of free(long, long). Memory allocated by this method should be freed using free(long, long)
    
    Specified by:
    
    allocate in interface com.hazelcast.internal.memory.MemoryAllocator
    
    Specified by:
    
    allocate in interface HazelcastMemoryManager
    
    Parameters:
    
    size - of requested memory block
    
    Returns:
    
    address of memory block
    
    Throws:
    
    NativeOutOfMemoryError - if not enough memory is available
  - reallocate
```
public long reallocate(long address,
                       long currentSize,
                       long newSize)
```
    Specified by:
    
    reallocate in interface com.hazelcast.internal.memory.MemoryAllocator
  - free
```
public void free(long address,
                 long size)
```
    Gives allocated memory block back to internal pool or to OS if pool is over capacity.
    Complement of allocate(long). Only memory allocated by allocate(long) can be freed using this method.
    
    Specified by:
    
    free in interface com.hazelcast.internal.memory.MemoryAllocator
    
    Specified by:
    
    free in interface HazelcastMemoryManager
    
    Parameters:
    
    address - address of memory block
    
    size - size of memory block
  - compact
```
public void compact()
```
    Description copied from interface: HazelcastMemoryManager
    
    Compacts the memory region.
    
    Specified by:
    
    compact in interface HazelcastMemoryManager
  - getUsableSize
```
public long getUsableSize(long address)
```
    Description copied from interface: HazelcastMemoryManager
    
    Returns size of memory block as if it belongs to and is allocated by this memory manager. If memory block is not known by this memory manager, HazelcastMemoryManager.SIZE_INVALID is returned.
    
    Specified by:
    
    getUsableSize in interface HazelcastMemoryManager
    
    Parameters:
    
    address - address of memory block
    
    Returns:
    
    size of memory block or HazelcastMemoryManager.SIZE_INVALID if it's unknown
  - validateAndGetUsableSize
```
public long validateAndGetUsableSize(long address)
```
    Description copied from interface: HazelcastMemoryManager
    
    Returns size of memory block if and only if it belongs to and is allocated by this memory manager. Otherwise, if memory block is not valid anymore or it is not known by this memory manager, HazelcastMemoryManager.SIZE_INVALID is returned.
    
    Specified by:
    
    validateAndGetUsableSize in interface HazelcastMemoryManager
    
    Parameters:
    
    address - address of memory block
    
    Returns:
    
    size of memory block or HazelcastMemoryManager.SIZE_INVALID if it's unknown
  - getAllocatedSize
```
public long getAllocatedSize(long address)
```
    Description copied from interface: HazelcastMemoryManager
    
    Returns allocated size of memory block as if it belongs to and is allocated by this memory manager. If memory block is not known by this memory manager, HazelcastMemoryManager.SIZE_INVALID is returned.
    Allocated size includes usable memory size plus any header or metadata region size reserved by memory manager.
    
    Specified by:
    
    getAllocatedSize in interface HazelcastMemoryManager
    
    Parameters:
    
    address - address of memory block
    
    Returns:
    
    size of memory block or HazelcastMemoryManager.SIZE_INVALID if it's unknown
    
    See Also:
    
    HazelcastMemoryManager.getUsableSize(long)
  - validateAndGetAllocatedSize
```
public long validateAndGetAllocatedSize(long address)
```
    Description copied from interface: HazelcastMemoryManager
    
    Returns allocated size of memory block if and only if it belongs to and is allocated by this memory manager. Otherwise, if memory block is not valid anymore or it is not known by this memory manager, HazelcastMemoryManager.SIZE_INVALID is returned.
    Allocated size includes usable memory size plus any header or metadata region size reserved by memory manager.
    
    Specified by:
    
    validateAndGetAllocatedSize in interface HazelcastMemoryManager
    
    Parameters:
    
    address - address of memory block
    
    Returns:
    
    size of memory block or HazelcastMemoryManager.SIZE_INVALID if it's unknown
    
    See Also:
    
    HazelcastMemoryManager.validateAndGetUsableSize(long)
  - newSequence
```
public long newSequence()
```
    Description copied from interface: HazelcastMemoryManager
    
    Creates a new sequence. This sequence is guaranteed to be atomically incremental.
    Use case for this sequence is to avoid ABA problem by using it with the address to create a "safe pointer" (address, sequence) to a memory block.
    
    Specified by:
    
    newSequence in interface HazelcastMemoryManager
    
    Returns:
    
    new sequence
  - getHeaderSize
```
public int getHeaderSize()
```
  - getGlobalMemoryManager
```
public com.hazelcast.memory.GlobalPoolingMemoryManager getGlobalMemoryManager()
```
  - getMemoryManager
```
public HazelcastMemoryManager getMemoryManager()
```
  - dispose
```
public void dispose()
```
    Specified by:
    
    dispose in interface com.hazelcast.nio.Disposable
  - isDisposed
```
public boolean isDisposed()
```
    Description copied from interface: HazelcastMemoryManager
    
    Gets the disposed state of this memory manager.
    
    Specified by:
    
    isDisposed in interface HazelcastMemoryManager
    
    Returns:
    
    true if this memory manager is destroyed, false otherwise
  - registerThread
```
public void registerThread(Thread thread)
```
  - newThreadLocalPoolingMemoryManager
```
protected ThreadLocalPoolingMemoryManager newThreadLocalPoolingMemoryManager(int minBlockSize,
                                                                             int pageSize,
                                                                             LibMalloc malloc,
                                                                             PooledNativeMemoryStats stats)
```
  - deregisterThread
```
public void deregisterThread(Thread thread)
```
  - gc
```
public final void gc()
```
    Specified by:
    
    gc in interface GarbageCollectable
  - getSystemAllocator
```
public com.hazelcast.internal.memory.MemoryAllocator getSystemAllocator()
```
    Specified by:
    
    getSystemAllocator in interface HazelcastMemoryManager
    
    Returns:
    
    the metadata memory allocator.
  - getMemoryStats
```
public com.hazelcast.memory.MemoryStats getMemoryStats()
```
    Specified by:
    
    getMemoryStats in interface HazelcastMemoryManager
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - provideMetrics
```
public void provideMetrics(com.hazelcast.internal.metrics.MetricsRegistry registry)
```
    Specified by:
    
    provideMetrics in interface com.hazelcast.internal.metrics.MetricsProvider

Class PoolingMemoryManager

Field Summary

Fields inherited from interface com.hazelcast.memory.HazelcastMemoryManager

Fields inherited from interface com.hazelcast.internal.memory.MemoryAllocator

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PoolingMemoryManager

PoolingMemoryManager

PoolingMemoryManager

PoolingMemoryManager

Method Detail

allocate

reallocate

free

compact

getUsableSize

validateAndGetUsableSize

getAllocatedSize

validateAndGetAllocatedSize

newSequence

getHeaderSize

getGlobalMemoryManager

getMemoryManager

dispose

isDisposed

registerThread

newThreadLocalPoolingMemoryManager

deregisterThread

gc

getSystemAllocator

getMemoryStats

toString

provideMetrics