com.fasterxml.sort.util.SegmentedBuffer Maven / Gradle / Ivy
Show all versions of java-merge-sort Show documentation
package com.fasterxml.sort.util;
import java.util.Arrays;
/**
* Helper class used instead of a standard JDK list or buffer,
* to avoid constant re-allocations.
*/
public class SegmentedBuffer
{
// // // Config constants
/**
* Let's start with relatively small chunks
*/
final static int INITIAL_CHUNK_SIZE = 1024;
/**
* Also: let's expand by doubling up until 16k entry chunks (which is 64k
* in size for 32-bit machines)
*/
final static int MAX_CHUNK_SIZE = (1 << 14);
// // // Data storage
private Node _bufferHead;
private Node _bufferTail;
/**
* Number of total buffered entries in this buffer, counting all instances
* within linked list formed by following {@link #_bufferHead}.
*/
private int _bufferedEntryCount;
// // // Simple reuse
/**
* Reusable Object array, stored here after buffer has been released having
* been used previously.
*/
private Object[] _freeBuffer;
/*
/**********************************************************
/* Construction
/**********************************************************
*/
public SegmentedBuffer() { }
/*
/**********************************************************
/* Public API
/**********************************************************
*/
/**
* Method called to start buffering process. Will ensure that the buffer
* is empty, and then return an object array to start chunking content on
*/
public Object[] resetAndStart()
{
if (_bufferedEntryCount > 0) {
_reset();
}
if (_freeBuffer == null) {
return new Object[INITIAL_CHUNK_SIZE];
}
return _freeBuffer;
}
/**
* Method called to add a full Object array as a chunk buffered within
* this buffer, and to obtain a new array to fill. Caller is not to use
* the array it gives; but to use the returned array for continued
* buffering.
*
* @param fullChunk Completed chunk that the caller is requesting
* to append to this buffer. It is generally chunk that was
* returned by an earlier call to {@link #resetAndStart} or
* {@link #appendCompletedChunk} (although this is not required or
* enforced)
*
* @return New chunk buffer for caller to fill
*/
public Object[] appendCompletedChunk(Object[] fullChunk)
{
Node next = new Node(fullChunk);
if (_bufferHead == null) { // first chunk
_bufferHead = _bufferTail = next;
} else { // have something already
_bufferTail.linkNext(next);
_bufferTail = next;
}
int len = fullChunk.length;
_bufferedEntryCount += len;
// double the size for small chunks
if (len < MAX_CHUNK_SIZE) {
len += len;
} else { // but by +25% for larger (to limit overhead)
len += (len >> 2);
}
return new Object[len];
}
/**
* Method called to indicate that the buffering process is now
* complete; and to construct a combined exactly-sized result
* array. Additionally the buffer itself will be reset to
* reduce memory retention.
*
* Resulting array will be of generic Object[] type:
* if a typed array is needed, use the method with additional
* type argument.
*/
public Object[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries)
{
int totalSize = lastChunkEntries + _bufferedEntryCount;
Object[] result = new Object[totalSize];
_copyTo(result, totalSize, lastChunk, lastChunkEntries);
// [Issue-5]: should reduce mem usage here
_reset();
return result;
}
/**
* Helper method that can be used to check how much free capacity
* will this instance start with. Can be used to choose the best
* instance to reuse, based on size of reusable object chunk
* buffer holds reference to.
*/
public int initialCapacity()
{
return (_freeBuffer == null) ? 0 : _freeBuffer.length;
}
/**
* Method that can be used to check how many Objects have been buffered
* within this buffer.
*/
public int bufferedSize() { return _bufferedEntryCount; }
/*
/**********************************************************************
/* Internal methods
/**********************************************************************
*/
private void _reset()
{
// can we reuse the last (and thereby biggest) array for next time?
if (_bufferedEntryCount > 0) {
if (_bufferTail != null) {
Object[] obs = _bufferTail.getData();
// also, let's clear it of contents as well, just in case
Arrays.fill(obs, null);
_freeBuffer = obs;
}
// either way, must discard current contents
_bufferHead = _bufferTail = null;
_bufferedEntryCount = 0;
}
}
private final void _copyTo(Object resultArray, int totalSize,
Object[] lastChunk, int lastChunkEntries)
{
int ptr = 0;
for (Node n = _bufferHead; n != null; n = n.next()) {
Object[] curr = n.getData();
int len = curr.length;
System.arraycopy(curr, 0, resultArray, ptr, len);
ptr += len;
}
System.arraycopy(lastChunk, 0, resultArray, ptr, lastChunkEntries);
ptr += lastChunkEntries;
// sanity check (could have failed earlier due to out-of-bounds, too)
if (ptr != totalSize) {
throw new IllegalStateException("Should have gotten "+totalSize+" entries, got "+ptr);
}
}
/*
/**********************************************************************
/* Helper classes
/**********************************************************************
*/
/**
* Helper class used to store actual data, in a linked list.
*/
private final static class Node
{
/**
* Data stored in this node. Array is considered to be full.
*/
private final Object[] _data;
private Node _next;
public Node(Object[] data) {
_data = data;
}
public Object[] getData() { return _data; }
public Node next() { return _next; }
public void linkNext(Node next)
{
if (_next != null) { // sanity check
throw new IllegalStateException();
}
_next = next;
}
}
}