diff options
| -rw-r--r-- | src/java/com/jogamp/common/nio/CachedBufferFactory.java | 340 | ||||
| -rw-r--r-- | src/junit/com/jogamp/common/nio/CachedBufferFactoryTest.java | 244 |
2 files changed, 584 insertions, 0 deletions
diff --git a/src/java/com/jogamp/common/nio/CachedBufferFactory.java b/src/java/com/jogamp/common/nio/CachedBufferFactory.java new file mode 100644 index 0000000..36bac13 --- /dev/null +++ b/src/java/com/jogamp/common/nio/CachedBufferFactory.java @@ -0,0 +1,340 @@ + +/* + * Copyright 2011 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ + +/* + * Created on Sunday, February 13 2011 15:17 + */ +package com.jogamp.common.nio; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; + +/** + * Buffer factory attempting to reduce buffer creation overhead. + * Direct ByteBuffers must be page aligned which increases creation overhead of + * small buffers significantly. + * This factory can be used as fixed size static or or dynamic allocating + * factory. The initial size and allocation size is configurable. + * <p> + * Fixed size factories may be used in systems with hard realtime requirements + * and/or predictable memory usage. + * </p> + * <p> + * concurrency info:<br/> + * <ul> + * <li>all create methods are threadsafe</li> + * <li>factories created with create(...) are <b>not</b> threadsafe</li> + * <li>factories created with createSynchronized(...) are threadsafe</li> + * </ul> + * </p> + * + * @author Michael Bien + */ +public class CachedBufferFactory { + + /** + * default size for internal buffer allocation. + */ + public static final int DEFAULT_ALLOCATION_SIZE = 1024 * 1024; + + private final int ALLOCATION_SIZE; + private ByteBuffer currentBuffer; + + private CachedBufferFactory() { + this(DEFAULT_ALLOCATION_SIZE, DEFAULT_ALLOCATION_SIZE); + } + + private CachedBufferFactory(int initialSize, int allocationSize) { + currentBuffer = Buffers.newDirectByteBuffer(initialSize); + ALLOCATION_SIZE = allocationSize; + } + + + /** + * Creates a factory with initial size and allocation size set to + * {@link #DEFAULT_ALLOCATION_SIZE}. + */ + public static CachedBufferFactory create() { + return new CachedBufferFactory(); + } + + /** + * Creates a factory with the specified initial size. The allocation size is set to + * {@link #DEFAULT_ALLOCATION_SIZE}. + */ + public static CachedBufferFactory create(int initialSize) { + return new CachedBufferFactory(initialSize, DEFAULT_ALLOCATION_SIZE); + } + + /** + * Creates a factory with the specified initial size. The allocation size is set to + * {@link #DEFAULT_ALLOCATION_SIZE}. + * @param fixed Creates a fixed size factory which will handle overflows (initial size) + * with RuntimeExceptions. + */ + public static CachedBufferFactory create(int initialSize, boolean fixed) { + return new CachedBufferFactory(initialSize, fixed?-1:DEFAULT_ALLOCATION_SIZE); + } + + /** + * Creates a factory with the specified initial size and allocation size. + */ + public static CachedBufferFactory create(int initialSize, int allocationSize) { + return new CachedBufferFactory(initialSize, allocationSize); + } + + + /** + * Synchronized version of {@link #create()}. + */ + public static CachedBufferFactory createSynchronized() { + return new SynchronizedCachedBufferFactory(); + } + + /** + * Synchronized version of {@link #create(int)}. + */ + public static CachedBufferFactory createSynchronized(int initialSize) { + return new SynchronizedCachedBufferFactory(initialSize, DEFAULT_ALLOCATION_SIZE); + } + + /** + * Synchronized version of {@link #create(int, boolean)}. + */ + public static CachedBufferFactory createSynchronized(int initialSize, boolean fixed) { + return new SynchronizedCachedBufferFactory(initialSize, fixed?-1:DEFAULT_ALLOCATION_SIZE); + } + + /** + * Synchronized version of {@link #create(int, int)}. + */ + public static CachedBufferFactory createSynchronized(int initialSize, int allocationSize) { + return new CachedBufferFactory(initialSize, allocationSize); + } + + /** + * Returns true only if this factory does not allow to allocate more buffers + * as limited by the initial size. + */ + public boolean isFixed() { + return ALLOCATION_SIZE == -1; + } + + /** + * Returns the allocation size used to create new internal buffers. + * This represents the initial size if {@link #isFixed()} == true. + */ + public int getAllocationSize() { + return ALLOCATION_SIZE; + } + + private void checkIfFixed() { + if(ALLOCATION_SIZE == -1) { + throw new RuntimeException("fixed size buffer factory ran out ouf bounds."); + } + } + + public ByteBuffer newDirectByteBuffer(int size) { + + // if large enough... just create it + if (size >= currentBuffer.capacity()) { + checkIfFixed(); + return Buffers.newDirectByteBuffer(size); + } + + // create new internal buffer if the old is running full + if (size > currentBuffer.remaining()) { + checkIfFixed(); + currentBuffer = Buffers.newDirectByteBuffer(ALLOCATION_SIZE); + } + + currentBuffer.limit(currentBuffer.position() + size); + ByteBuffer result = currentBuffer.slice(); + currentBuffer.position(currentBuffer.limit()); + currentBuffer.limit(currentBuffer.capacity()); + return result; + } + + + public ByteBuffer newDirectByteBuffer(byte[] values, int offset, int lenght) { + return (ByteBuffer)newDirectByteBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public ByteBuffer newDirectByteBuffer(byte[] values, int offset) { + return newDirectByteBuffer(values, offset, values.length-offset); + } + + public ByteBuffer newDirectByteBuffer(byte[] values) { + return newDirectByteBuffer(values, 0); + } + + public DoubleBuffer newDirectDoubleBuffer(int numElements) { + return newDirectByteBuffer(numElements * Buffers.SIZEOF_DOUBLE).asDoubleBuffer(); + } + + public DoubleBuffer newDirectDoubleBuffer(double[] values, int offset, int lenght) { + return (DoubleBuffer)newDirectDoubleBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public DoubleBuffer newDirectDoubleBuffer(double[] values, int offset) { + return newDirectDoubleBuffer(values, offset, values.length - offset); + } + + public DoubleBuffer newDirectDoubleBuffer(double[] values) { + return newDirectDoubleBuffer(values, 0); + } + + public FloatBuffer newDirectFloatBuffer(int numElements) { + return newDirectByteBuffer(numElements * Buffers.SIZEOF_FLOAT).asFloatBuffer(); + } + + public FloatBuffer newDirectFloatBuffer(float[] values, int offset, int lenght) { + return (FloatBuffer)newDirectFloatBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public FloatBuffer newDirectFloatBuffer(float[] values, int offset) { + return newDirectFloatBuffer(values, offset, values.length - offset); + } + + public FloatBuffer newDirectFloatBuffer(float[] values) { + return newDirectFloatBuffer(values, 0); + } + + public IntBuffer newDirectIntBuffer(int numElements) { + return newDirectByteBuffer(numElements * Buffers.SIZEOF_INT).asIntBuffer(); + } + + public IntBuffer newDirectIntBuffer(int[] values, int offset, int lenght) { + return (IntBuffer)newDirectIntBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public IntBuffer newDirectIntBuffer(int[] values, int offset) { + return newDirectIntBuffer(values, offset, values.length - offset); + } + + public IntBuffer newDirectIntBuffer(int[] values) { + return newDirectIntBuffer(values, 0); + } + + public LongBuffer newDirectLongBuffer(int numElements) { + return newDirectByteBuffer(numElements * Buffers.SIZEOF_LONG).asLongBuffer(); + } + + public LongBuffer newDirectLongBuffer(long[] values, int offset, int lenght) { + return (LongBuffer)newDirectLongBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public LongBuffer newDirectLongBuffer(long[] values, int offset) { + return newDirectLongBuffer(values, offset, values.length - offset); + } + + public LongBuffer newDirectLongBuffer(long[] values) { + return newDirectLongBuffer(values, 0); + } + + public ShortBuffer newDirectShortBuffer(int numElements) { + return newDirectByteBuffer(numElements * Buffers.SIZEOF_SHORT).asShortBuffer(); + } + + public ShortBuffer newDirectShortBuffer(short[] values, int offset, int lenght) { + return (ShortBuffer)newDirectShortBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public ShortBuffer newDirectShortBuffer(short[] values, int offset) { + return newDirectShortBuffer(values, offset, values.length - offset); + } + + public ShortBuffer newDirectShortBuffer(short[] values) { + return newDirectShortBuffer(values, 0); + } + + public CharBuffer newDirectCharBuffer(int numElements) { + return newDirectByteBuffer(numElements * Buffers.SIZEOF_SHORT).asCharBuffer(); + } + + public CharBuffer newDirectCharBuffer(char[] values, int offset, int lenght) { + return (CharBuffer)newDirectCharBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public CharBuffer newDirectCharBuffer(char[] values, int offset) { + return newDirectCharBuffer(values, offset, values.length - offset); + } + + public CharBuffer newDirectCharBuffer(char[] values) { + return newDirectCharBuffer(values, 0); + } + + @Override + public boolean equals(Object obj) { + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final CachedBufferFactory other = (CachedBufferFactory) obj; + if (this.ALLOCATION_SIZE != other.ALLOCATION_SIZE) { + return false; + } + if (this.currentBuffer != other.currentBuffer && (this.currentBuffer == null || !this.currentBuffer.equals(other.currentBuffer))) { + return false; + } + return true; + } + + @Override + public String toString() { + return getClass().getName()+"[static:"+isFixed()+" alloc size:"+getAllocationSize()+"]"; + } + + + // nothing special, just synchronized + private static class SynchronizedCachedBufferFactory extends CachedBufferFactory { + + private SynchronizedCachedBufferFactory() { + super(); + } + + private SynchronizedCachedBufferFactory(int size, int step) { + super(size, step); + } + + @Override + public synchronized ByteBuffer newDirectByteBuffer(int size) { + return super.newDirectByteBuffer(size); + } + + } + +} diff --git a/src/junit/com/jogamp/common/nio/CachedBufferFactoryTest.java b/src/junit/com/jogamp/common/nio/CachedBufferFactoryTest.java new file mode 100644 index 0000000..0b10fe8 --- /dev/null +++ b/src/junit/com/jogamp/common/nio/CachedBufferFactoryTest.java @@ -0,0 +1,244 @@ +/* + * Copyright 2011 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ +package com.jogamp.common.nio; + +import java.nio.ByteBuffer; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.concurrent.Callable; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static java.lang.System.*; +import static org.junit.Assert.*; + +/** + * + * @author Michael Bien + */ +public class CachedBufferFactoryTest { + + private final int BUFFERCOUNT = 120; + + private static int[] sizes; + private static int[] values; + private static IntBuffer[] buffers; + + @Before + public void setup() { + + sizes = new int[BUFFERCOUNT]; + values = new int[sizes.length]; + buffers = new IntBuffer[sizes.length]; + + Random rnd = new Random(7); + + // setup + for (int i = 0; i < sizes.length; i++) { + sizes[i] = rnd.nextInt(80)+1; + values[i] = rnd.nextInt(); + } + + } + + @After + public void teardown() { + sizes = null; + values = null; + buffers = null; + } + + @Test + public void dynamicTest() { + + CachedBufferFactory factory = CachedBufferFactory.create(64); + + // create + for (int i = 0; i < sizes.length; i++) { + buffers[i] = factory.newDirectIntBuffer(sizes[i]); + fill(buffers[i], values[i]); + } + + // check + checkBuffers(buffers, sizes, values); + + } + + @Test + public void dynamicConcurrentTest() throws InterruptedException, ExecutionException { + + final CachedBufferFactory factory = CachedBufferFactory.createSynchronized(24); + + List<Callable<Object>> callables = new ArrayList<Callable<Object>>(); + + final CountDownLatch latch = new CountDownLatch(10); + + // create + for (int i = 0; i < sizes.length; i++) { + final int n = i; + Callable<Object> c = new Callable<Object>() { + public Object call() throws Exception { + latch.countDown(); + latch.await(); + buffers[n] = factory.newDirectIntBuffer(sizes[n]); + fill(buffers[n], values[n]); + return null; + } + }; + callables.add(c); + } + + ExecutorService dathVader = Executors.newFixedThreadPool(10); + dathVader.invokeAll(callables); + + dathVader.shutdown(); + + // check + checkBuffers(buffers, sizes, values); + + } + + private void checkBuffers(IntBuffer[] buffers, int[] sizes, int[] values) { + for (int i = 0; i < buffers.length; i++) { + IntBuffer buffer = buffers[i]; + assertEquals(sizes[i], buffer.capacity()); + assertEquals(0, buffer.position()); + assertTrue(equals(buffer, values[i])); + } + } + + @Test + public void staticTest() { + + CachedBufferFactory factory = CachedBufferFactory.create(10, true); + + for (int i = 0; i < 5; i++) { + factory.newDirectByteBuffer(2); + } + + try{ + factory.newDirectByteBuffer(1); + fail(); + }catch (RuntimeException ex) { + // expected + } + + } + + private void fill(IntBuffer buffer, int value) { + while(buffer.remaining() != 0) + buffer.put(value); + + buffer.rewind(); + } + + private boolean equals(IntBuffer buffer, int value) { + while(buffer.remaining() != 0) { + if(value != buffer.get()) + return false; + } + + buffer.rewind(); + return true; + } + + + /* load testing */ + + private int size = 4; + private int iterations = 10000; + +// @Test + public Object loadTest() { + CachedBufferFactory factory = CachedBufferFactory.create(); + ByteBuffer[] buffer = new ByteBuffer[iterations]; + for (int i = 0; i < buffer.length; i++) { + buffer[i] = factory.newDirectByteBuffer(size); + } + return buffer; + } + +// @Test + public Object referenceTest() { + ByteBuffer[] buffer = new ByteBuffer[iterations]; + for (int i = 0; i < buffer.length; i++) { + buffer[i] = Buffers.newDirectByteBuffer(size); + } + return buffer; + } + + + public static void main(String[] args) { + + CachedBufferFactoryTest test = new CachedBufferFactoryTest(); + + out.print("warmup..."); + Object obj = null; + for (int i = 0; i < 100; i++) { + obj = test.referenceTest(); + obj = test.loadTest(); + gc(); + } + out.println("done"); + + test = new CachedBufferFactoryTest(); + gc(); + + for (int i = 0; i < 10; i++) { + + out.println("allocation size: "+test.size); + + long time = System.currentTimeMillis(); + obj = test.referenceTest(); + if(obj == null) return; // ref lock + + out.println("reference: "+ (System.currentTimeMillis()-time)); + + gc(); + + time = currentTimeMillis(); + obj = test.loadTest(); + if(obj == null) return; // ref lock + + out.println("factory: "+ (System.currentTimeMillis()-time)); + + gc(); + + test.size*=2; + } + + } + +} |