Class ByteBlockPool

java.lang.Object
org.apache.lucene.util.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 Details

    • BYTE_BLOCK_SHIFT

      public static final int BYTE_BLOCK_SHIFT
      See Also:
    • BYTE_BLOCK_SIZE

      public static final int BYTE_BLOCK_SIZE
      See Also:
    • BYTE_BLOCK_MASK

      public static final int BYTE_BLOCK_MASK
      See Also:
    • 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:
  • Constructor Details

  • Method Details

    • reset

      public void reset()
      Resets the pool to its initial state reusing the first buffer and fills all buffers with 0 bytes before they reused or passed to ByteBlockPool.Allocator.recycleByteBlocks(byte[][], int, int). Calling nextBuffer() is not needed after reset.
    • 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:
    • 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.