Package org.terracotta.offheapstore.storage.allocator

Class LongBestFitAllocator

  • All Implemented Interfaces:
    java.lang.Iterable<java.lang.Long>, Allocator
    public final class LongBestFitAllocator
extends java.lang.Object
implements Allocator
    An aggressively best-fit allocator.

    • Constructor Detail

      • LongBestFitAllocator

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

    • Method Detail

      • 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

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • dump

        private java.lang.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)

      • 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)

      • iterator

        public java.util.Iterator<java.lang.Long> iterator()
        Specified by:
        iterator in interface java.lang.Iterable<java.lang.Long>