Class IntegerBestFitAllocator

java.lang.Object
org.terracotta.offheapstore.storage.allocator.IntegerBestFitAllocator
All Implemented Interfaces:
Iterable<Long>, Allocator
public final class IntegerBestFitAllocator extends Object implements Allocator
An aggressively best-fit allocator.

  • Field Details

    • DEBUG

      private static final boolean DEBUG

    • VALIDATING

      private static final boolean VALIDATING

    • SIZE_T_SIZE

      private static final int SIZE_T_SIZE
      See Also:

    • SIZE_T_BITSIZE

      private static final int SIZE_T_BITSIZE
      See Also:

    • MALLOC_ALIGNMENT

      private static final int MALLOC_ALIGNMENT
      See Also:

    • CHUNK_ALIGN_MASK

      private static final int CHUNK_ALIGN_MASK
      See Also:

    • MCHUNK_SIZE

      private static final int MCHUNK_SIZE
      See Also:

    • CHUNK_OVERHEAD

      private static final int CHUNK_OVERHEAD
      See Also:

    • MIN_CHUNK_SIZE

      private static final int MIN_CHUNK_SIZE
      See Also:

    • MAX_REQUEST

      private static final int MAX_REQUEST
      See Also:

    • MIN_REQUEST

      private static final int MIN_REQUEST
      See Also:

    • TOP_FOOT_SIZE

      private static final int TOP_FOOT_SIZE

    • MINIMAL_SIZE

      private static final int MINIMAL_SIZE

    • TOP_FOOT_OFFSET

      private static final int TOP_FOOT_OFFSET

    • PINUSE_BIT

      private static final int PINUSE_BIT
      See Also:

    • CINUSE_BIT

      private static final int CINUSE_BIT
      See Also:

    • FLAG4_BIT

      private static final int FLAG4_BIT
      See Also:

    • INUSE_BITS

      private static final int INUSE_BITS
      See Also:

    • FLAG_BITS

      private static final int FLAG_BITS
      See Also:

    • NSMALLBINS

      private static final int NSMALLBINS
      See Also:

    • NTREEBINS

      private static final int NTREEBINS
      See Also:

    • SMALLBIN_SHIFT

      private static final int SMALLBIN_SHIFT
      See Also:

    • TREEBIN_SHIFT

      private static final int TREEBIN_SHIFT
      See Also:

    • MIN_LARGE_SIZE

      private static final int MIN_LARGE_SIZE
      See Also:

    • MAX_SMALL_SIZE

      private static final int MAX_SMALL_SIZE
      See Also:

    • MAX_SMALL_REQUEST

      private static final int MAX_SMALL_REQUEST
      See Also:

    • storage

      private final OffHeapStorageArea storage

    • smallMap

      private int smallMap

    • treeMap

      private int treeMap

    • smallBins

      private final int[] smallBins

    • treeBins

      private final int[] treeBins

    • designatedVictimSize

      private int designatedVictimSize

    • designatedVictim

      private int designatedVictim

    • topSize

      private int topSize

    • top

      private int top

    • occupied

      private int occupied

  • Constructor Details

    • IntegerBestFitAllocator

      public IntegerBestFitAllocator(OffHeapStorageArea storage)
      Create a best fit allocator backed by the given OffHeapStorageArea.
      Parameters:
      storage - source of ByteBuffer instances

  • Method Details

    • clear

      public void clear()
      Specified by:
      clear in interface Allocator

    • expand

      public void expand(long increase)
      Specified by:
      expand in interface Allocator

    • allocate

      public long allocate(long size)
      Specified by:
      allocate in interface Allocator

    • free

      public void free(long address)
      Specified by:
      free in interface Allocator

    • occupied

      public long occupied()
      Specified by:
      occupied in interface Allocator

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • dump

      private String dump()

    • dlmalloc

      private int dlmalloc(int bytes)

    • allocateFromSmallBin

      private int allocateFromSmallBin(int index, int nb)

    • splitFromSmallBin

      private int splitFromSmallBin(int index, int nb)

    • replaceDesignatedVictim

      private void replaceDesignatedVictim(int p, int s)

    • splitSmallFromTree

      private int splitSmallFromTree(int nb)

    • splitFromTree

      private int splitFromTree(int nb)

    • splitFromDesignatedVictim

      private int splitFromDesignatedVictim(int nb)

    • splitFromTop

      private int splitFromTop(int nb)

    • dlfree

      private void dlfree(int mem, boolean shrink)

    • insertChunk

      private void insertChunk(int p, int s)

    • insertSmallChunk

      private void insertSmallChunk(int p, int s)

    • insertLargeChunk

      private void insertLargeChunk(int x, int s)

    • unlinkChunk

      private void unlinkChunk(int p, int s)

    • unlinkSmallChunk

      private void unlinkSmallChunk(int p, int s)

    • unlinkLargeChunk

      private void unlinkLargeChunk(int x)

    • chunkInUse

      private boolean chunkInUse(int p)

    • previousInUse

      private boolean previousInUse(int p)

    • isInUse

      private boolean isInUse(int p)

    • chunkSize

      private int chunkSize(int p)

    • clearPreviousInUse

      private void clearPreviousInUse(int p)

    • nextChunk

      private int nextChunk(int p)

    • prevChunk

      private int prevChunk(int p)

    • nextPreviousInUse

      private boolean nextPreviousInUse(int p)

    • setFoot

      private void setFoot(int p, int s)

    • setSizeAndPreviousInUseOfFreeChunk

      private void setSizeAndPreviousInUseOfFreeChunk(int p, int s)

    • setFreeWithPreviousInUse

      private void setFreeWithPreviousInUse(int p, int s, int n)

    • setInUseAndPreviousInUse

      private void setInUseAndPreviousInUse(int p, int s)

    • setSizeAndPreviousInUseOfInUseChunk

      private void setSizeAndPreviousInUseOfInUseChunk(int p, int s)

    • prevFoot

      private int prevFoot(int p)

    • prevFoot

      private void prevFoot(int p, int value)

    • head

      private int head(int p)

    • head

      private void head(int p, int value)

    • forward

      private int forward(int p)

    • forward

      private void forward(int p, int value)

    • backward

      private int backward(int p)

    • backward

      private void backward(int p, int value)

    • child

      private int child(int p, int index)

    • child

      private void child(int p, int index, int value)

    • parent

      private int parent(int p)

    • parent

      private void parent(int p, int value)

    • index

      private int index(int p)

    • index

      private void index(int p, int value)

    • leftmostChild

      private int leftmostChild(int x)

    • padRequest

      private static int padRequest(int req)

    • chunkToMem

      private static int chunkToMem(int p)

    • memToChunk

      private static int memToChunk(int p)

    • okAddress

      private static boolean okAddress(int a)

    • okNext

      private static boolean okNext(int p, int n)

    • isAligned

      private static boolean isAligned(int a)

    • alignOffset

      private static int alignOffset(int a)

    • isSmall

      private static boolean isSmall(int s)

    • smallBinIndex

      private static int smallBinIndex(int s)

    • smallBinIndexToSize

      private static int smallBinIndexToSize(int i)

    • treeBinIndex

      private static int treeBinIndex(int s)

    • markSmallMap

      private void markSmallMap(int i)

    • clearSmallMap

      private void clearSmallMap(int i)

    • smallMapIsMarked

      private boolean smallMapIsMarked(int i)

    • markTreeMap

      private void markTreeMap(int i)

    • clearTreeMap

      private void clearTreeMap(int i)

    • treeMapIsMarked

      private boolean treeMapIsMarked(int i)

    • leftShiftForTreeIndex

      private static int leftShiftForTreeIndex(int i)

    • minSizeForTreeIndex

      private static int minSizeForTreeIndex(int i)

    • leftBits

      private static int leftBits(int i)

    • validateAllocator

      public void validateAllocator()
      Debugging Support
      Specified by:
      validateAllocator in interface Allocator

    • validateMallocedPointer

      public int validateMallocedPointer(int m)

    • checkAnyChunk

      private void checkAnyChunk(int p)

    • checkTopChunk

      private void checkTopChunk(int p)

    • checkInUseChunk

      private void checkInUseChunk(int p)

    • checkFreeChunk

      private void checkFreeChunk(int p)

    • checkMallocedChunk

      private void checkMallocedChunk(int mem, int s)

    • checkTree

      private void checkTree(int t)

    • checkTreeBin

      private void checkTreeBin(int index)

    • checkSmallBin

      private void checkSmallBin(int index)

    • traverseAndCheck

      private int traverseAndCheck()

    • findFreeChunk

      private boolean findFreeChunk(int x)

    • getLastUsedPointer

      public long getLastUsedPointer()
      Specified by:
      getLastUsedPointer in interface Allocator

    • getLastUsedAddress

      public long getLastUsedAddress()
      Specified by:
      getLastUsedAddress in interface Allocator

    • getMinimalSize

      public int getMinimalSize()
      Specified by:
      getMinimalSize in interface Allocator

    • getMaximumAddress

      public long getMaximumAddress()
      Specified by:
      getMaximumAddress in interface Allocator

    • iterator

      public Iterator<Long> iterator()
      Specified by:
      iterator in interface Iterable<Long>