Class ByteSlicePool


  • final class ByteSlicePool
    extends java.lang.Object
    Class that Posting and PostingVector use to write interleaved byte streams into shared fixed-size byte[] arrays. The idea is to allocate slices of increasing lengths. For example, the first slice is 5 bytes, the next slice is 14, etc. We start by writing our bytes into the first 5 bytes. When we hit the end of the slice, we allocate the next slice and then write the address of the new slice into the last 4 bytes of the previous slice (the "forwarding address").

    Each slice is filled with 0's initially, and we mark the end with a non-zero byte. This way the methods that are writing into the slice don't need to record its length and instead allocate a new slice once they hit a non-zero byte.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      int allocKnownSizeSlice​(byte[] slice, int upto)
      Create a new byte slice in continuation of the provided slice and return its length and offset into the pool.
      int allocSlice​(byte[] slice, int upto)
      Creates a new byte slice in continuation of the provided slice and return its offset into the pool.
      int newSlice​(int size)
      Allocates a new slice with the given size and level 0.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • pool

        public final ByteBlockPool pool
        The underlying structure consists of fixed-size blocks. We overlay variable-length slices on top. Each slice is contiguous in memory, i.e. it does not straddle multiple blocks.
      • LEVEL_SIZE_ARRAY

        public static final int[] LEVEL_SIZE_ARRAY
        An array holding the level sizes for byte slices. The first slice is 5 bytes, the second is 14, and so on.
      • NEXT_LEVEL_ARRAY

        public static final int[] NEXT_LEVEL_ARRAY
        An array holding indexes for the LEVEL_SIZE_ARRAY, to quickly navigate to the next slice level. These are encoded on 4 bits in the slice, so the values in this array should be less than 16.

        NEXT_LEVEL_ARRAY[x] == x + 1, except for the last element, where NEXT_LEVEL_ARRAY[x] == x, pointing at the maximum slice size.

      • FIRST_LEVEL_SIZE

        public static final int FIRST_LEVEL_SIZE
        The first level size for new slices.
    • Constructor Detail

    • Method Detail

      • newSlice

        public int newSlice​(int size)
        Allocates a new slice with the given size and level 0.
        Returns:
        the position where the slice starts
      • allocSlice

        public int allocSlice​(byte[] slice,
                              int upto)
        Creates a new byte slice in continuation of the provided slice and return its offset into the pool.
        Parameters:
        slice - the current slice
        upto - the offset into the current slice, which is expected to point to the last byte of the slice
        Returns:
        the new slice's offset in the pool
      • allocKnownSizeSlice

        public int allocKnownSizeSlice​(byte[] slice,
                                       int upto)
        Create a new byte slice in continuation of the provided slice and return its length and offset into the pool.
        Parameters:
        slice - the current slice
        upto - the offset into the current slice, which is expected to point to the last byte of the slice
        Returns:
        the new slice's length on the lower 8 bits and the offset into the pool on the other 24 bits