Class LongBestFitAllocator

java.lang.Object
org.terracotta.offheapstore.storage.allocator.LongBestFitAllocator
All Implemented Interfaces:
Iterable<Long>, Allocator
public final class LongBestFitAllocator 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_BITSIZE

      private static final int SIZE_T_BITSIZE
      See Also:

    • SIZE_T_SIZE

      private static final int SIZE_T_SIZE
      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 long MIN_CHUNK_SIZE
      See Also:

    • MAX_REQUEST

      private static final long MAX_REQUEST
      See Also:

    • MIN_REQUEST

      private static final long MIN_REQUEST
      See Also:

    • TOP_FOOT_SIZE

      private static final long TOP_FOOT_SIZE

    • MINIMAL_SIZE

      private static final long MINIMAL_SIZE

    • TOP_FOOT_OFFSET

      private static final long 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 long[] smallBins

    • treeBins

      private final long[] treeBins

    • designatedVictimSize

      private long designatedVictimSize

    • designatedVictim

      private long designatedVictim

    • topSize

      private long topSize

    • top

      private long top

    • occupied

      private long occupied

  • Constructor Details

    • LongBestFitAllocator

      public LongBestFitAllocator(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 long dlmalloc(long bytes)

    • allocateFromSmallBin

      private long allocateFromSmallBin(int index, long nb)

    • splitFromSmallBin

      private long splitFromSmallBin(int index, long nb)

    • replaceDesignatedVictim

      private void replaceDesignatedVictim(long p, long s)

    • splitSmallFromTree

      private long splitSmallFromTree(long nb)

    • splitFromTree

      private long splitFromTree(long nb)

    • splitFromDesignatedVictim

      private long splitFromDesignatedVictim(long nb)

    • splitFromTop

      private long splitFromTop(long nb)

    • dlfree

      private void dlfree(long mem, boolean shrink)

    • insertChunk

      private void insertChunk(long p, long s)

    • insertSmallChunk

      private void insertSmallChunk(long p, long s)

    • insertLargeChunk

      private void insertLargeChunk(long x, long s)

    • unlinkChunk

      private void unlinkChunk(long p, long s)

    • unlinkSmallChunk

      private void unlinkSmallChunk(long p, long s)

    • unlinkLargeChunk

      private void unlinkLargeChunk(long x)

    • chunkInUse

      private boolean chunkInUse(long p)

    • previousInUse

      private boolean previousInUse(long p)

    • isInUse

      private boolean isInUse(long p)

    • chunkSize

      private long chunkSize(long p)

    • clearPreviousInUse

      private void clearPreviousInUse(long p)

    • nextChunk

      private long nextChunk(long p)

    • prevChunk

      private long prevChunk(long p)

    • nextPreviousInUse

      private boolean nextPreviousInUse(long p)

    • setFoot

      private void setFoot(long p, long s)

    • setSizeAndPreviousInUseOfFreeChunk

      private void setSizeAndPreviousInUseOfFreeChunk(long p, long s)

    • setFreeWithPreviousInUse

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

    • setInUseAndPreviousInUse

      private void setInUseAndPreviousInUse(long p, long s)

    • setSizeAndPreviousInUseOfInUseChunk

      private void setSizeAndPreviousInUseOfInUseChunk(long p, long s)

    • prevFoot

      private long prevFoot(long p)

    • prevFoot

      private void prevFoot(long p, long value)

    • head

      private long head(long p)

    • head

      private void head(long p, long value)

    • forward

      private long forward(long p)

    • forward

      private void forward(long p, long value)

    • backward

      private long backward(long p)

    • backward

      private void backward(long p, long value)

    • child

      private long child(long p, int index)

    • child

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

    • parent

      private long parent(long p)

    • parent

      private void parent(long p, long value)

    • index

      private int index(long p)

    • index

      private void index(long p, int value)

    • leftmostChild

      private long leftmostChild(long x)

    • padRequest

      private static long padRequest(long req)

    • chunkToMem

      private static long chunkToMem(long p)

    • memToChunk

      private static long memToChunk(long p)

    • okAddress

      private static boolean okAddress(long a)

    • okNext

      private static boolean okNext(long p, long n)

    • isAligned

      private static boolean isAligned(long a)

    • alignOffset

      private static long alignOffset(long a)

    • isSmall

      private static boolean isSmall(long s)

    • smallBinIndex

      private static int smallBinIndex(long s)

    • smallBinIndexToSize

      private static int smallBinIndexToSize(int i)

    • treeBinIndex

      private static int treeBinIndex(long 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 long validateMallocedPointer(long m)

    • checkAnyChunk

      private void checkAnyChunk(long p)

    • checkTopChunk

      private void checkTopChunk(long p)

    • checkInUseChunk

      private void checkInUseChunk(long p)

    • checkFreeChunk

      private void checkFreeChunk(long p)

    • checkMallocedChunk

      private void checkMallocedChunk(long mem, long s)

    • checkTree

      private void checkTree(long t)

    • checkTreeBin

      private void checkTreeBin(int index)

    • checkSmallBin

      private void checkSmallBin(int index)

    • traverseAndCheck

      private long traverseAndCheck()

    • findFreeChunk

      private boolean findFreeChunk(long 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>