/**
* Expert: Resets the pool to its initial state reusing the first buffer. Calling {@link
* ByteBlockPool#nextBuffer()} is not needed after reset.
*
* @param zeroFillBuffers if <code>true</code> the buffers are filled with <tt>0</tt>. This should
* be set to <code>true</code> if this pool is used with slices.
* @param reuseFirst if <code>true</code> the first buffer will be reused and calling {@link
* ByteBlockPool#nextBuffer()} is not needed after reset iff the block pool was used before
* ie. {@link ByteBlockPool#nextBuffer()} was called before.
*/
public void reset(boolean zeroFillBuffers, boolean reuseFirst) {
if (bufferUpto != -1) {
// We allocated at least one buffer
if (zeroFillBuffers) {
for (int i = 0; i < bufferUpto; i++) {
// Fully zero fill buffers that we fully used
Arrays.fill(buffers[i], (byte) 0);
}
// Partial zero fill the final buffer
Arrays.fill(buffers[bufferUpto], 0, byteUpto, (byte) 0);
}
if (bufferUpto > 0 || !reuseFirst) {
final int offset = reuseFirst ? 1 : 0;
// Recycle all but the first buffer
allocator.recycleByteBlocks(buffers, offset, 1 + bufferUpto);
Arrays.fill(buffers, offset, 1 + bufferUpto, null);
}
if (reuseFirst) {
// Re-use the first buffer
bufferUpto = 0;
byteUpto = 0;
byteOffset = 0;
buffer = buffers[0];
} else {
bufferUpto = -1;
byteUpto = BYTE_BLOCK_SIZE;
byteOffset = -BYTE_BLOCK_SIZE;
buffer = null;
}
}
}
public void nextBuffer() {
if (1 + bufferUpto == buffers.length) {
byte[][] newBuffers = new byte[(int) (buffers.length * 1.5)][];
System.arraycopy(buffers, 0, newBuffers, 0, buffers.length);
buffers = newBuffers;
}
buffer = buffers[1 + bufferUpto] = allocator.getByteBlock(trackAllocations);
bufferUpto++;
byteUpto = 0;
byteOffset += DocumentsWriter.BYTE_BLOCK_SIZE;
}
/**
* 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 {@link ByteBlockPool#reset()} call
* will advance the pool to its first buffer immediately.
*/
public void nextBuffer() {
if (1 + bufferUpto == buffers.length) {
byte[][] newBuffers =
new byte[ArrayUtil.oversize(buffers.length + 1, NUM_BYTES_OBJECT_REF)][];
System.arraycopy(buffers, 0, newBuffers, 0, buffers.length);
buffers = newBuffers;
}
buffer = buffers[1 + bufferUpto] = allocator.getByteBlock();
bufferUpto++;
byteUpto = 0;
byteOffset += BYTE_BLOCK_SIZE;
}
public void reset() {
if (bufferUpto != -1) {
// We allocated at least one buffer
for (int i = 0; i < bufferUpto; i++)
// Fully zero fill buffers that we fully used
Arrays.fill(buffers[i], (byte) 0);
// Partial zero fill the final buffer
Arrays.fill(buffers[bufferUpto], 0, byteUpto, (byte) 0);
if (bufferUpto > 0)
// Recycle all but the first buffer
allocator.recycleByteBlocks(buffers, 1, 1 + bufferUpto);
// Re-use the first buffer
bufferUpto = 0;
byteUpto = 0;
byteOffset = 0;
buffer = buffers[0];
}
}
public void put(int n) {
alloc_.put(n);
hiredout -= n;
available += n;
display();
}
public void get(int n) throws InterruptedException {
alloc_.get(n);
available -= n;
hiredout += n;
display();
}