From 32b373d5860db27a45d92835d503610bc1ca9225 Mon Sep 17 00:00:00 2001
From: Michael Bien <mbien@fh-landshut.de>
Date: Sun, 13 Feb 2011 21:20:46 +0100
Subject: added CachedBufferFactory + test. factory supports dynamic and static
allocation schemes and has a synchronized and a unsynchronized
implementation.
---
.../com/jogamp/common/nio/CachedBufferFactory.java | 340 +++++++++++++++++++++
1 file changed, 340 insertions(+)
create mode 100644 src/java/com/jogamp/common/nio/CachedBufferFactory.java
(limited to 'src/java/com/jogamp/common/nio/CachedBufferFactory.java')
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);
+ }
+
+ }
+
+}
--
cgit v1.2.3