MemoryManager (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- com.bigdata.rwstore.sector.MemoryManager

All Implemented Interfaces:

ICounterSetAccess, IAllocationManagerStore, IStreamStore, IAllocationManager, IHistoryManager, IStore, IMemoryManager, ISectorManager
```
public class MemoryManager
extends Object
implements IMemoryManager, ISectorManager
```
The MemoryManager manages an off-heap Direct ByteBuffer. It uses the new SectorAllocator to allocate slots within the address range. The interface is designed to support efficient transfer between NIO buffers. The most complex aspect of the implementation is the BLOB representation, requiring a mapping across multiple allocation slots. This is managed using recursive calls in the main three methods: allocate, free and get.

Author:

Martyn Cutcher

Constructor Summary

Constructors
Constructor and Description
`MemoryManager(DirectBufferPool pool)` Create a new `MemoryManager`.
`MemoryManager(DirectBufferPool pool, int sectors)` Create a new `MemoryManager`.
`MemoryManager(DirectBufferPool pool, int sectors, boolean blocks, Properties properties)` Create a new `MemoryManager`.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abortContext(IAllocationContext context)` Indicates that the allocation context will no longer be used and that the allocations made within the context should be discarded.
`void`	`addToFreeList(SectorAllocator sector)` When sufficient allocations have been freed for recycling that a threshold of availability of reached for all block sizes, then the allocator calls back to the SectorManager to signal it is available to be returned to the free list.
`long`	`alloc(byte[] buf, int size, IAllocationContext context)` Writes data on the store.
`long`	`allocate(ByteBuffer data)` Version of `IMemoryManager.allocate(ByteBuffer, boolean)` which is either blocking or non-blocking depending on whether or not the memory manager is set in a blocking mode.
`long`	`allocate(ByteBuffer data, boolean blocks)` Allocates space on the backing resource and copies the provided data.
`long`	`allocate(ByteBuffer data, IAllocationContext context)`
`long`	`allocate(int nbytes)` Return the address of a new allocation sufficient to store the specified number of bytes of application data.
`long`	`allocate(int nbytes, boolean blocks)` Return the address of a new allocation sufficient to store the specified number of bytes of application data.
`int`	`allocationSize(long addr)` Return the size of the application data for the allocation with the given address.
`int`	`checkDeferredFrees(AbstractJournal journal)` This method is invoked during the commit protocol and gives the backing store an opportunity to check whether storage associated with deferred frees can now be released.
`void`	`clear()` Clears all current allocations.
`void`	`close()` Close the backing storage.
`void`	`commit()` Global commit on the backing store.
`IMemoryManager`	`createAllocationContext()` Maintain allocationContext to check for session protection
`void`	`deferFree(int rwaddr, int sze)`
`void`	`delete(long addr, IAllocationContext context)` Delete the data associated with the address within the allocation context.
`void`	`detachContext(IAllocationContext context)` Indicates that the allocation context will no longer be used, but that the allocations made within the context should be preserved.
`protected void`	`finalize()`
`void`	`free(long addr)` Frees the address and makes available for recycling
`void`	`free(long addr, IAllocationContext context)`
`void`	`free(long addr, int size)` Frees allocated storage (clears the bit to enable recycling after the next commit).
`ByteBuffer[]`	`get(long addr)` Return an array of `ByteBuffer`s providing an updatable view onto the backing allocation.
`long`	`getAllocationCount()` The #of allocation spanned by this allocation context (including any any child allocation contexts).
`int`	`getAssociatedSlotSize(int addr)`
`long`	`getCapacity()` The maximum #of bytes which are available to the memory manager.
`Lock`	`getCommitLock()` Optionally return a `Lock` that must be used (when non- `null`) to make the `IStore.commit()` / `IStore.postCommit()` strategy atomic.
`CounterSet`	`getCounters()` Return performance counters.
`void`	`getData(long l, byte[] buf)` Read data of a known size from the store.
`long`	`getExtent()` The total #of bytes in the backing buffers currently attached to the `MemoryManager`.
`InputStream`	`getInputStream(long addr)` Return an input stream from which a previously written stream may be read back.
`long`	`getLastReleaseTime()` If history is retained this returns the time for which data was most recently released.
`long`	`getMaxMemoryCapacity()` The maximum capacity in bytes of the managed memory.
`int`	`getMaxSectors()` Return the maximum #of sectors which may be allocated.
`IPSOutputStream`	`getOutputStream()` Return an output stream which can be used to write on the backing store.
`IPSOutputStream`	`getOutputStream(IAllocationContext context)` Return an output stream which can be used to write on the backing store within the given allocation context.
`long`	`getPhysicalAddress(long addr)` Determine the unencoded physical address
`int`	`getSectorCount()` Return the #of sectors which are currently in use.
`int`	`getSectorSize()` The size in bytes of the backing sector.
`long`	`getSlotBytes()` Return the #of bytes of consumed by allocation slots allocated against this `IMemoryManager` (including any child allocation contexts).
`File`	`getStoreFile()` Retrieves store file.
`long`	`getUserBytes()` Return the #of bytes of application data allocated against this `IMemoryManager` (including any child allocation contexts).
`boolean`	`isBlocking()` Return `true` iff the default policy of this `MemoryManager` instance is to block if an allocation can not be made (due to exhaustion of the maximum number of backing buffers for the `MemoryManager` instance).
`boolean`	`isCommitted(long addr)` Return `true` iff the allocation having that address is flagged as committed.
`IAllocationContext`	`newAllocationContext(boolean isolated)` Creates a context to be used to isolate updates to within the context until it is released to the parent environment.
`IRawTx`	`newTx()` A hook used to support session protection by incrementing and decrementing a transaction counter within the `IStore`.
`void`	`postCommit()` Hook that supports synchronization with an external commit before which a rollback to "pre-commit" state is supported.
`byte[]`	`read(long addr)` Return a copy of the data stored at that address.
`void`	`registerExternalCache(ConcurrentWeakValueCache<Long,ICommitter> externalCache, int dataSize)` Call made from AbstractJournal to register the cache used.
`void`	`removeFromFreeList(SectorAllocator sector)` This request is made when the sectorAllocator no longer has a full set of block allocations available.
`long`	`saveDeferrals()` Saves the current list of delete blocks, returning the address allocated.
`String`	`toString()`
`void`	`trimSector(long trim, SectorAllocator sector)` When a sector is first created, it will remain at the head of the free list until one of two conditions has been reached: The allocation has been saturated. The bit space has been filled.
`long`	`write(ByteBuffer data, IAllocationContext context)` Write the data within the allocation context.

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

- Constructor Detail
  - MemoryManager
```
public MemoryManager(DirectBufferPool pool)
```
    Create a new MemoryManager.
    The backing DirectBufferPool may be either bounded or (effectively) unbounded. The MemoryManager will be (effectively) unbounded. If either the pool is bounded, then blocking allocation requests may block, otherwise allocation requests will be non-blocking.
    The garbage collection of direct ByteBuffers depends on a full GC pass. In an application which managers its heap pressure well, full GC passes are rare. Therefore, the best practice is to share an unbounded pool across multiple purposes. Since there are typically multiple users of the pool, the demand can not always be predicated and deadlocks can arise with a bounded pool.
    Individual buffers will be allocated as necessary and released if they become empty. However, since allocation patterns may cause the in use data to be scattered across the allocated buffers, the backing buffers may not be returned to the backing pool until the top-level allocation context is cleared.
    Any storage allocated by this instance will be released no later than when the instance is finalized. Storage may be returned to the pool within the life cycle of the MemoryManager using clear(). Nested allocation contexts may be created and managed using createAllocationContext().
    
    Parameters:
    pool - The pool from which the MemoryManager will allocate its buffers (each "sector" is one buffer).
    
    Throws:
    
    IllegalArgumentException - if pool is null.
  - MemoryManager
```
public MemoryManager(DirectBufferPool pool,
             int sectors)
```
    Create a new MemoryManager.
    The backing DirectBufferPool may be either bounded or (effectively) unbounded. The MemoryManager may also be bounded or (effectively) unbounded. If either the pool or the memory manager is bounded, then blocking allocation requests may block. Neither non-blocking allocation requests nor allocation requests made against an unbounded memory manager backed by an unbounded pool will block. The preferred method for bounding the memory manager is to specify a maximum #of buffers which it may consume from the pool.
    The garbage collection of direct ByteBuffers depends on a full GC pass. In an application which managers its heap pressure well, full GC passes are rare. Therefore, the best practice is to share an unbounded pool across multiple purposes. Since there are typically multiple users of the pool, the demand can not always be predicated and deadlocks can arise with a bounded pool.
    Individual buffers will be allocated as necessary and released if they become empty. However, since allocation patterns may cause the in use data to be scattered across the allocated buffers, the backing buffers may not be returned to the backing pool until the top-level allocation context is cleared.
    Any storage allocated by this instance will be released no later than when the instance is finalized. Storage may be returned to the pool within the life cycle of the MemoryManager using clear(). Nested allocation contexts may be created and managed using createAllocationContext().
    
    Parameters:
    pool - The pool from which the MemoryManager will allocate its buffers (each "sector" is one buffer).
    sectors - The maximum #of buffers which the MemoryManager will allocate from that pool (each "sector" is one buffer). This may be Integer.MAX_VALUE for an effectively unbounded capacity.
    
    Throws:
    
    IllegalArgumentException - if pool is null.
    
    IllegalArgumentException - if sectors is non-positive.
  - MemoryManager
```
public MemoryManager(DirectBufferPool pool,
             int sectors,
             boolean blocks,
             Properties properties)
```
    Create a new MemoryManager.
    The backing DirectBufferPool may be either bounded or (effectively) unbounded. The MemoryManager may also be bounded or (effectively) unbounded. If either the pool or the memory manager is bounded, then blocking allocation requests may block. Neither non-blocking allocation requests nor allocation requests made against an unbounded memory manager backed by an unbounded pool will block. The preferred method for bounding the memory manager is to specify a maximum #of buffers which it may consume from the pool.
    The garbage collection of direct ByteBuffers depends on a full GC pass. In an application which managers its heap pressure well, full GC passes are rare. Therefore, the best practice is to share an unbounded pool across multiple purposes. Since there are typically multiple users of the pool, the demand can not always be predicated and deadlocks can arise with a bounded pool.
    Individual buffers will be allocated as necessary and released if they become empty. However, since allocation patterns may cause the in use data to be scattered across the allocated buffers, the backing buffers may not be returned to the backing pool until the top-level allocation context is cleared.
    Any storage allocated by this instance will be released no later than when the instance is finalized. Storage may be returned to the pool within the life cycle of the MemoryManager using clear(). Nested allocation contexts may be created and managed using createAllocationContext().
    
    Parameters:
    pool - The pool from which the MemoryManager will allocate its buffers (each "sector" is one buffer).
    sectors - The maximum #of buffers which the MemoryManager will allocate from that pool (each "sector" is one buffer). This may be Integer.MAX_VALUE for an effectively unbounded capacity.
    blocks - When true an allocation request will block until it can be satisfied. When false and allocation request that can not be satisfied immediately will result in a MemoryManagerOutOfMemory.
    properties - Used to communicate various configuration properties, including AbstractTransactionService.Options#MIN_RELEASE_AGE (optional).
    
    Throws:
    
    IllegalArgumentException - if pool is null.
    
    IllegalArgumentException - if sectors is non-positive.
    See Also:
    Per query memory limit for analytic query mode.
- Method Detail
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - getMaxSectors
```
public int getMaxSectors()
```
    Return the maximum #of sectors which may be allocated.
    
    Specified by:
    
    getMaxSectors in interface IMemoryManager
  - isBlocking
```
public boolean isBlocking()
```
    Return true iff the default policy of this MemoryManager instance is to block if an allocation can not be made (due to exhaustion of the maximum number of backing buffers for the MemoryManager instance). Return false iff the allocation will throw a MemoryManagerOutOfMemory exception if the backing memory pool is exhausted.
    
    See Also:
    Per query memory limit for analytic query mode.
  - getSectorCount
```
public int getSectorCount()
```
    Return the #of sectors which are currently in use.
    
    Specified by:
    
    getSectorCount in interface IMemoryManager
  - getSectorSize
```
public int getSectorSize()
```
    The size in bytes of the backing sector. This is the upper bound on the #of bytes which may be stored against a single sector.
    
    Specified by:
    
    getSectorSize in interface IMemoryManager
  - getMaxMemoryCapacity
```
public long getMaxMemoryCapacity()
```
    The maximum capacity in bytes of the managed memory.
  - allocate
```
public long allocate(ByteBuffer data)
```
    Description copied from interface: IMemoryManager
    
    Version of IMemoryManager.allocate(ByteBuffer, boolean) which is either blocking or non-blocking depending on whether or not the memory manager is set in a blocking mode.
    
    Specified by:
    
    allocate in interface IMemoryManager
    
    Parameters:
    data - The data will be copied to the backing resource. For each buffer in this array, the position will be advanced to the limit.
  - allocate
```
public long allocate(ByteBuffer data,
            boolean blocks)
```
    Description copied from interface: IMemoryManager
    
    Allocates space on the backing resource and copies the provided data.
    
    Specified by:
    
    allocate in interface IMemoryManager
    
    Parameters:
    data - The data will be copied to the backing resource. For each buffer in this array, the position will be advanced to the limit.
    blocks - When true the request will block until the memory is available for the allocation.
    
    Returns:
    the address to be passed to the get method to retrieve the data.
  - allocate
```
public long allocate(int nbytes)
```
    Description copied from interface: IMemoryManager
    
    Return the address of a new allocation sufficient to store the specified number of bytes of application data. This is the blocking version of IMemoryManager.allocate(int).
    
    Specified by:
    
    allocate in interface IMemoryManager
    
    Parameters:
    nbytes - The size of the allocation request.
    
    Returns:
    The address of the allocation.
  - allocate
```
public long allocate(int nbytes,
            boolean blocks)
```
    Description copied from interface: IMemoryManager
    
    Return the address of a new allocation sufficient to store the specified number of bytes of application data.
    
    Specified by:
    
    allocate in interface IMemoryManager
    
    Parameters:
    nbytes - The size of the allocation request.
    blocks - When true the method will block until the allocation request can be satisfied. When false a MemoryManagerOutOfMemory will be thrown.
    
    Returns:
    The address of the allocation.
  - get
```
public ByteBuffer[] get(long addr)
```
    Description copied from interface: IMemoryManager
    Return an array of ByteBuffers providing an updatable view onto the backing allocation.
    The ByteBuffer[] return enables the handling of blobs that span more than a single slot, without the need to create an intermediate ByteBuffer. This method is designed for use with zero-copy NIO. Furthermore, since the ByteBuffers in the returned array are not read-only, they can be updated directly. In this way the IMemoryManager.allocate(int) can be used in conjunction with get to provide more flexibility when storing data.
    Using ByteBuffer:put the returned array can be efficiently copied to another ByteBuffer:
```
 ByteBuffer mybb;
 ByteBuffer[] bufs = get(addr);
 for (ByteBuffer b : bufs) {
        mybb.put(b);
 }
 
```
    CAUTION: Do not hold onto the ByteBuffer longer than is necessary. If the allocation is released by IMemoryManager.free(long) or IMemoryManager.clear(), then the memory backing the ByteBuffer could be reallocated by another DirectBufferPool consumer.
    Specified by:
    
    get in interface IMemoryManager
    
    Parameters:
    addr - An previously allocated address.
    
    Returns:
    array of ByteBuffers
  - read
```
public byte[] read(long addr)
```
    Description copied from interface: IMemoryManager
    
    Return a copy of the data stored at that address. This method is intended for use with patterns where the IMemoryManager is treated as a persistence store.
    
    Specified by:
    
    read in interface IMemoryManager
    
    Parameters:
    addr - The address.
    
    Returns:
    A copy of the data stored at that address.
  - free
```
public void free(long addr)
```
    Description copied from interface: IMemoryManager
    
    Frees the address and makes available for recycling
    
    Specified by:
    
    free in interface IMemoryManager
    
    Parameters:
    addr - to be freed
  - getPhysicalAddress
```
public long getPhysicalAddress(long addr)
```
    Description copied from interface: IMemoryManager
    
    Determine the unencoded physical address
    
    Specified by:
    
    getPhysicalAddress in interface IMemoryManager
    
    Parameters:
    addr - The encoded address
    
    Returns:
    an unencoded address offset
  - clear
```
public void clear()
```
    Description copied from interface: IMemoryManager
    
    Clears all current allocations. Clearing an allocation context makes the backing heap storage available to immediate reallocation. Clearing the allocation context of the top-level IMemoryManager will release any direct ByteBuffers back to the pool from which they were allocated.
    CAUTION: Do not clear an allocation context until you know that all threads with access to that allocation context have either been terminated or released their reference to that allocation context.
    
    Specified by:
    
    clear in interface IMemoryManager
  - addToFreeList
```
public void addToFreeList(SectorAllocator sector)
```
    Description copied from interface: ISectorManager
    
    When sufficient allocations have been freed for recycling that a threshold of availability of reached for all block sizes, then the allocator calls back to the SectorManager to signal it is available to be returned to the free list.
    
    Specified by:
    
    addToFreeList in interface ISectorManager
    
    Parameters:
    sector - to be added
  - removeFromFreeList
```
public void removeFromFreeList(SectorAllocator sector)
```
    Description copied from interface: ISectorManager
    
    This request is made when the sectorAllocator no longer has a full set of block allocations available. The allocator will issue this callback to help the SectorManager manage an effective freelist of available allocators.
    
    Specified by:
    
    removeFromFreeList in interface ISectorManager
    
    Parameters:
    sector - to be removed
  - trimSector
```
public void trimSector(long trim,
              SectorAllocator sector)
```
    Description copied from interface: ISectorManager
    When a sector is first created, it will remain at the head of the free list until one of two conditions has been reached:
    1. The allocation has been saturated.
    2. The bit space has been filled.
    In the case of (2), then it is possible that significant allocation space cannot be utilized - which will happen if the average allocation is less than 1K. In this situation, the sector can be trimmed and the space made available to the next sector. trimSector will only be called in this condition - on the first occasion that the allocator is removed from the freeList.
    Specified by:
    
    trimSector in interface ISectorManager
    
    Parameters:
    trim - - the amount by which the sector allocation can be reduced
  - createAllocationContext
```
public IMemoryManager createAllocationContext()
```
    Maintain allocationContext to check for session protection
    
    Specified by:
    
    createAllocationContext in interface IMemoryManager
  - allocationSize
```
public int allocationSize(long addr)
```
    Description copied from interface: IMemoryManager
    
    Return the size of the application data for the allocation with the given address.
    
    Specified by:
    
    allocationSize in interface IMemoryManager
    
    Parameters:
    addr - The address.
    
    Returns:
    The #of bytes of in the applications allocation request.
  - getCapacity
```
public long getCapacity()
```
    The maximum #of bytes which are available to the memory manager.
  - getExtent
```
public long getExtent()
```
    The total #of bytes in the backing buffers currently attached to the MemoryManager.
  - getAllocationCount
```
public long getAllocationCount()
```
    Description copied from interface: IMemoryManager
    
    The #of allocation spanned by this allocation context (including any any child allocation contexts).
    
    Specified by:
    
    getAllocationCount in interface IMemoryManager
  - getSlotBytes
```
public long getSlotBytes()
```
    Description copied from interface: IMemoryManager
    
    Return the #of bytes of consumed by allocation slots allocated against this IMemoryManager (including any child allocation contexts).
    
    Specified by:
    
    getSlotBytes in interface IMemoryManager
  - getUserBytes
```
public long getUserBytes()
```
    Description copied from interface: IMemoryManager
    
    Return the #of bytes of application data allocated against this IMemoryManager (including any child allocation contexts). Due to the overhead of the storage allocation scheme, this value may be smaller than IMemoryManager.getSlotBytes().
    
    Specified by:
    
    getUserBytes in interface IMemoryManager
  - getCounters
```
public CounterSet getCounters()
```
    Description copied from interface: ICounterSetAccess
    
    Return performance counters.
    
    Specified by:
    
    getCounters in interface ICounterSetAccess
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - alloc
```
public long alloc(byte[] buf,
         int size,
         IAllocationContext context)
```
    Description copied from interface: IStore
    
    Writes data on the store.
    
    Specified by:
    
    alloc in interface IStore
    
    Returns:
    the allocated address
  - close
```
public void close()
```
    Description copied from interface: IStore
    
    Close the backing storage.
    
    Specified by:
    
    close in interface IStore
  - free
```
public void free(long addr,
        int size)
```
    Description copied from interface: IStore
    
    Frees allocated storage (clears the bit to enable recycling after the next commit).
    
    Specified by:
    
    free in interface IStore
    
    Parameters:
    addr - the storage address to be freed
  - getAssociatedSlotSize
```
public int getAssociatedSlotSize(int addr)
```
    Specified by:
    
    getAssociatedSlotSize in interface IStore
    
    Parameters:
    addr - - the address
    
    Returns:
    the size of the slot associated
  - getData
```
public void getData(long l,
           byte[] buf)
```
    Description copied from interface: IStore
    
    Read data of a known size from the store.
    
    Specified by:
    
    getData in interface IStore
    
    Parameters:
    l - the address of the data
    buf - the buffer of the size required!
  - getStoreFile
```
public File getStoreFile()
```
    Description copied from interface: IStore
    
    Retrieves store file. Can be used to delete the store after the IStore has been released
    
    Specified by:
    
    getStoreFile in interface IStore
    
    Returns:
    the File object
  - getOutputStream
```
public IPSOutputStream getOutputStream()
```
    Description copied from interface: IStreamStore
    
    Return an output stream which can be used to write on the backing store. You can recover the address used to read back the data from the IPSOutputStream.
    
    Specified by:
    
    getOutputStream in interface IStreamStore
    
    Returns:
    The output stream.
  - getOutputStream
```
public IPSOutputStream getOutputStream(IAllocationContext context)
```
    Description copied from interface: IAllocationManagerStore
    
    Return an output stream which can be used to write on the backing store within the given allocation context. You can recover the address used to read back the data from the IPSOutputStream.
    
    Specified by:
    
    getOutputStream in interface IAllocationManagerStore
    
    Parameters:
    context - The context within which any allocations are made by the returned IPSOutputStream.
    
    Returns:
    an output stream to stream data to and to retrieve an address to later stream the data back.
  - getInputStream
```
public InputStream getInputStream(long addr)
```
    Description copied from interface: IStreamStore
    
    Return an input stream from which a previously written stream may be read back.
    
    Specified by:
    
    getInputStream in interface IStreamStore
    
    Parameters:
    addr - The address at which the stream was written.
    
    Returns:
    an input stream for the data for provided address
  - commit
```
public void commit()
```
    Description copied from interface: IStore
    
    Global commit on the backing store. Previously committed data which has been marked as IStore.free(long, int) is now available for recycling. However, recycling can not occur if session protection is active.
    
    Specified by:
    
    commit in interface IStore
  - getCommitLock
```
public Lock getCommitLock()
```
    Description copied from interface: IStore
    
    Optionally return a Lock that must be used (when non- null) to make the IStore.commit() / IStore.postCommit() strategy atomic.
    
    Specified by:
    
    getCommitLock in interface IStore
  - postCommit
```
public void postCommit()
```
    Description copied from interface: IStore
    
    Hook that supports synchronization with an external commit before which a rollback to "pre-commit" state is supported.
    
    Specified by:
    
    postCommit in interface IStore
  - registerExternalCache
```
public void registerExternalCache(ConcurrentWeakValueCache<Long,ICommitter> externalCache,
                         int dataSize)
```
    Description copied from interface: IHistoryManager
    
    Call made from AbstractJournal to register the cache used. This can then be accessed to clear entries when storage is made available for re-cycling.
    Note: It is not safe to clear at the point of the delete request since the data could still be loaded if the data is retained for a period due to a non-zero retention period or session protection.
    
    Specified by:
    
    registerExternalCache in interface IHistoryManager
  - saveDeferrals
```
public long saveDeferrals()
```
    Description copied from interface: IHistoryManager
    
    Saves the current list of delete blocks, returning the address allocated. This can be used later to retrieve the addresses of allocations to be freed.
    Writes the content of currentTxnFreeList to the store.
    These are the current buffered frees that have yet been saved into a block referenced from the deferredFreeList
    
    Specified by:
    
    saveDeferrals in interface IHistoryManager
    
    Returns:
    the address of the deferred addresses saved on the store, or zero if none.
    See Also:
    DeleteBlockCommitter
  - deferFree
```
public void deferFree(int rwaddr,
             int sze)
```
  - checkDeferredFrees
```
public int checkDeferredFrees(AbstractJournal journal)
```
    Description copied from interface: IHistoryManager
    
    This method is invoked during the commit protocol and gives the backing store an opportunity to check whether storage associated with deferred frees can now be released. The backing store needs to reply the deferred free blocks for the commit points that will be released, mark those addresses as free, and free the logged delete blocks.
    
    Specified by:
    
    checkDeferredFrees in interface IHistoryManager
    
    Returns:
    number of addresses freed
    See Also:
    AbstractJournal#commitNow()
  - newTx
```
public IRawTx newTx()
```
    Description copied from interface: IHistoryManager
    
    A hook used to support session protection by incrementing and decrementing a transaction counter within the IStore. As long as a transaction is active we can not release data which is currently marked as freed but was committed at the point the session started.
    
    Specified by:
    
    newTx in interface IHistoryManager
  - getLastReleaseTime
```
public long getLastReleaseTime()
```
    Description copied from interface: IHistoryManager
    
    If history is retained this returns the time for which data was most recently released. No request can be made for data earlier than this.
    
    Specified by:
    
    getLastReleaseTime in interface IHistoryManager
    
    Returns:
    latest data release time
  - abortContext
```
public void abortContext(IAllocationContext context)
```
    Description copied from interface: IAllocationManager
    
    Indicates that the allocation context will no longer be used and that the allocations made within the context should be discarded. The allocations associated with the context are discarded, as are any deletes made within the scope of that allocation context. The allocators associated with the allocation context are return to the global list of available allocators.
    
    Specified by:
    
    abortContext in interface IAllocationManager
    
    Parameters:
    context - The application object which serves as the allocation context.
  - detachContext
```
public void detachContext(IAllocationContext context)
```
    Description copied from interface: IAllocationManager
    
    Indicates that the allocation context will no longer be used, but that the allocations made within the context should be preserved. The allocations associated with the context are propagated to the parent allocation context. The IStore is the top-level parent of allocation contexts. The allocators associated with the allocation context are return to the global list of available allocators.
    
    Specified by:
    
    detachContext in interface IAllocationManager
    
    Parameters:
    context - The application object which serves as the allocation context.
  - isCommitted
```
public boolean isCommitted(long addr)
```
    Description copied from interface: IMemoryManager
    
    Return true iff the allocation having that address is flagged as committed. The caller must be holding the allocation lock in order for the result to remain valid outside of the method call.
    
    Specified by:
    
    isCommitted in interface IMemoryManager
    
    Parameters:
    addr - The address.
    
    Returns:
    true iff the address is currently committed.
  - allocate
```
public long allocate(ByteBuffer data,
            IAllocationContext context)
```
    Specified by:
    
    allocate in interface IMemoryManager
  - write
```
public long write(ByteBuffer data,
         IAllocationContext context)
```
    Description copied from interface: IAllocationManagerStore
    
    Write the data within the allocation context. The write is not visible outside of the allocation until the allocation context has been merged into the parent allocation context.
    
    Specified by:
    
    write in interface IAllocationManagerStore
    
    Parameters:
    data - The data.
    context - The allocation context.
    
    Returns:
    The address at which the data was written.
  - free
```
public void free(long addr,
        IAllocationContext context)
```
    Specified by:
    
    free in interface IMemoryManager
  - delete
```
public void delete(long addr,
          IAllocationContext context)
```
    Description copied from interface: IAllocationManagerStore
    
    Delete the data associated with the address within the allocation context. The delete is not visible outside of the allocation until the allocation context has been merged into the parent allocation context.
    
    Specified by:
    
    delete in interface IAllocationManagerStore
    
    Parameters:
    addr - The address whose allocation is to be deleted.
    context - The allocation context.
  - newAllocationContext
```
public IAllocationContext newAllocationContext(boolean isolated)
```
    Description copied from interface: IAllocationManager
    
    Creates a context to be used to isolate updates to within the context until it is released to the parent environment.
    
    Specified by:
    
    newAllocationContext in interface IAllocationManager
    
    Returns:
    a new IAlocationContext

Class MemoryManager

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MemoryManager

MemoryManager

MemoryManager

Method Detail

finalize

getMaxSectors

isBlocking

getSectorCount

getSectorSize

getMaxMemoryCapacity

allocate

allocate

allocate

allocate

get

read

free

getPhysicalAddress

clear

addToFreeList

removeFromFreeList

trimSector

createAllocationContext

allocationSize

getCapacity

getExtent

getAllocationCount

getSlotBytes

getUserBytes

getCounters

toString

alloc

close

free

getAssociatedSlotSize

getData

getStoreFile

getOutputStream

getOutputStream

getInputStream

commit

getCommitLock

postCommit

registerExternalCache

saveDeferrals

deferFree

checkDeferredFrees

newTx

getLastReleaseTime

abortContext

detachContext

isCommitted

allocate

write

free

delete

newAllocationContext