Package org.terracotta.offheapstore.storage.allocator

Class IntegerBestFitAllocator

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

    • Constructor Detail

      • IntegerBestFitAllocator

        public IntegerBestFitAllocator​(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 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)

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

      • iterator

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