Package org.apache.lucene.util

Class ByteBlockPool

  • public final class ByteBlockPool
extends Object
    Class that Posting and PostingVector use to write 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.

    • Field Detail

      • buffers

        public byte[][] buffers
        array of buffers currently used in the pool. Buffers are allocated if needed don't modify this outside of this class.

      • byteUpto

        public int byteUpto
        Where we are in head buffer

      • buffer

        public byte[] buffer
        Current head buffer

      • byteOffset

        public int byteOffset
        Current head offset

      • NEXT_LEVEL_ARRAY

        public static final int[] NEXT_LEVEL_ARRAY
        An array holding the offset into the LEVEL_SIZE_ARRAY to quickly navigate to the next slice level.

      • LEVEL_SIZE_ARRAY

        public static final int[] LEVEL_SIZE_ARRAY
        An array holding the level sizes for byte slices.

      • FIRST_LEVEL_SIZE

        public static final int FIRST_LEVEL_SIZE
        The first level size for new slices
        See Also:
        newSlice(int)

    • Method Detail

      • reset

        public void reset​(boolean zeroFillBuffers,
                  boolean reuseFirst)
        Expert: Resets the pool to its initial state reusing the first buffer. Calling nextBuffer() is not needed after reset.
        Parameters:
        zeroFillBuffers - if true the buffers are filled with 0. This should be set to true if this pool is used with slices.
        reuseFirst - if true the first buffer will be reused and calling nextBuffer() is not needed after reset iff the block pool was used before ie. nextBuffer() was called before.

      • nextBuffer

        public void nextBuffer()
        Advances the pool to its next buffer. This method should be called once after the constructor to initialize the pool. In contrast to the constructor a reset() call will advance the pool to its first buffer immediately.

      • newSlice

        public int newSlice​(int size)
        Allocates a new slice with the given size.
        See Also:
        FIRST_LEVEL_SIZE

      • allocSlice

        public int allocSlice​(byte[] slice,
                      int upto)
        Creates a new byte slice with the given starting size and returns the slices offset in the pool.

      • setBytesRef

        public void setBytesRef​(BytesRef term,
                        int textStart)

      • append

        public void append​(BytesRef bytes)
        Appends the bytes in the provided BytesRef at the current position.

      • readBytes

        public void readBytes​(long offset,
                      byte[] bytes,
                      int off,
                      int length)
        Reads bytes bytes out of the pool starting at the given offset with the given length into the given byte array at offset off.

        Note: this method allows to copy across block boundaries.