ObjectCache redesigned.

js-labs · js-labs · commit 4c1d0ef8be2d · 2015-09-17T23:43:34.000+03:00
diff --git a/core/src/org/jsl/collider/ObjectCache.java b/core/src/org/jsl/collider/ObjectCache.java
@@ -30,8 +30,8 @@ public abstract class ObjectCache<TYPE>
     private final TYPE [] m_cache;
     private int m_size;
     private int m_gets;
-    private int m_miss;
     private int m_puts;
+    private int m_miss;
 
     protected abstract TYPE allocateObject();
 
@@ -86,22 +86,20 @@ public final TYPE get()
         return allocateObject();
     }
 
-    public final void clear( Logger logger, int initialSize )
+    public final void clear( Logger logger )
     {
         for (int idx=0; idx<m_size; idx++)
         {
             assert( m_cache[idx] != null );
             m_cache[idx] = null;
         }
 
-        if (m_size < initialSize)
+        if (m_puts != m_gets)
         {
             if (logger.isLoggable(Level.WARNING))
             {
                 logger.log( Level.WARNING,
-                        m_name + ": resource leak detected: current size " +
-                        m_size + " less than initial size " + initialSize +
-                        " (get=" + m_gets + ", miss=" + m_miss + ", put=" + m_puts + ")." );
+                        m_name + ": resource leak detected: gets=" + m_gets + ", puts=" + m_puts + "." );
             }
         }
         else
@@ -117,7 +115,7 @@ public final void clear( Logger logger, int initialSize )
         m_size = 0;
     }
 
-    public final String clear( int initialSize )
+    public String clear( int initialSize )
     {
         for (int idx=0; idx<m_size; idx++)
         {
@@ -128,11 +126,11 @@ public final String clear( int initialSize )
         final int size = m_size;
         m_size = 0;
 
-        if (size < initialSize)
+        if (m_puts != m_gets)
         {
             return m_name + ": WARNING: resource leak detected: current size " +
                    size + " less than initial size " + initialSize +
-                    " (" + m_gets + ", " + m_miss + ", " + m_puts + ").";
+                   " (" + m_gets + ", " + m_miss + ", " + m_puts + ").";
         }
         else
         {
diff --git a/core/src/org/jsl/collider/RetainableByteBuffer.java b/core/src/org/jsl/collider/RetainableByteBuffer.java
@@ -123,12 +123,18 @@ public final boolean clearSafe()
             return false;
     }
 
-    public RetainableByteBuffer slice()
+    public final RetainableByteBuffer slice()
     {
         retain();
         return new Slice( m_buf.slice() );
     }
 
+    public final RetainableByteBuffer duplicate()
+    {
+        retain();
+        return new Slice( m_buf.duplicate() );
+    }
+
     /*
      * ByteBuffer interface mimic.
      */
diff --git a/core/src/org/jsl/collider/RetainableByteBufferCache.java b/core/src/org/jsl/collider/RetainableByteBufferCache.java
@@ -23,38 +23,39 @@
 
 public class RetainableByteBufferCache extends ObjectCache<RetainableByteBuffer>
 {
-    private class BufferImpl extends RetainableByteBufferImpl
+    private static class BufferImpl extends RetainableByteBufferImpl
     {
-        public BufferImpl( ByteBuffer buf )
+        private RetainableByteBufferCache m_cache;
+
+        public BufferImpl( ByteBuffer buf, RetainableByteBufferCache cache )
         {
             super( buf );
+            m_cache = cache;
         }
 
         protected void finalRelease()
         {
             super.finalRelease();
-            RetainableByteBufferCache.this.put( this );
+            m_cache.put( this );
         }
     }
 
-    private final int m_bufferCapacity;
     private final boolean m_useDirectBuffer;
+    private final int m_bufferCapacity;
 
     protected BufferImpl allocateObject()
     {
-        final ByteBuffer buf = 
+        final ByteBuffer buf =
                 m_useDirectBuffer
                     ? ByteBuffer.allocateDirect( m_bufferCapacity )
                     : ByteBuffer.allocate( m_bufferCapacity );
-        return new BufferImpl( buf );
+        return new BufferImpl( buf, this );
     }
 
-    public RetainableByteBufferCache( int bufferCapacity, boolean useDirectBuffer, int maxSize, int initialSize )
+    public RetainableByteBufferCache( boolean useDirectBuffer, int bufferCapacity, int size )
     {
-        super( RetainableByteBuffer.class.getSimpleName() + "-" + bufferCapacity, new RetainableByteBuffer[maxSize] );
-        m_bufferCapacity = bufferCapacity;
+        super( RetainableByteBufferCache.class.getSimpleName() + "-" + bufferCapacity, new RetainableByteBuffer[size] );
         m_useDirectBuffer = useDirectBuffer;
-        for (int idx=0; idx<initialSize; idx++)
-            put( allocateObject() );
+        m_bufferCapacity = bufferCapacity;
     }
 }
diff --git a/core/src/org/jsl/collider/RetainableByteBufferPool.java b/core/src/org/jsl/collider/RetainableByteBufferPool.java
@@ -68,41 +68,24 @@ public final void release( int bytes )
 
     private static class ChunkCache extends ObjectCache<Chunk>
     {
-        private final boolean m_useDirectBuffers;
+        private final boolean m_useDirectBuffer;
         private final int m_bufferCapacity;
-        private final int m_initialSize;
 
-        public ChunkCache( boolean useDirectBuffers, int bufferCapacity, int maxCacheSize, int initialSize )
+        public ChunkCache( boolean useDirectBuffer, int bufferCapacity, int maxCacheSize )
         {
             super( "ByteBufferPool[" + bufferCapacity + "]", new Chunk[maxCacheSize] );
-
-            m_useDirectBuffers = useDirectBuffers;
+            m_useDirectBuffer = useDirectBuffer;
             m_bufferCapacity = bufferCapacity;
-            m_initialSize = initialSize;
-
-            for (int cc=initialSize; cc>0; cc--)
-                put( allocateObject() );
         }
 
         protected Chunk allocateObject()
         {
-            ByteBuffer buf;
-            if (m_useDirectBuffers)
-                buf = ByteBuffer.allocateDirect( m_bufferCapacity );
-            else
-                buf = ByteBuffer.allocate( m_bufferCapacity );
+            final ByteBuffer buf =
+                    m_useDirectBuffer
+                            ? ByteBuffer.allocateDirect( m_bufferCapacity )
+                            : ByteBuffer.allocate( m_bufferCapacity );
             return new Chunk( this, buf );
         }
-
-        public final void clear( Logger logger )
-        {
-            clear( logger, m_initialSize );
-        }
-
-        public final String clear()
-        {
-            return clear( m_initialSize );
-        }
     }
 
     private static class BufferImpl extends RetainableByteBuffer
@@ -267,7 +250,7 @@ public RetainableByteBufferPool( int chunkSize )
     public RetainableByteBufferPool( int chunkSize, boolean useDirectBuffers )
     {
         m_useDirectBuffers = useDirectBuffers;
-        m_cache = new ChunkCache( m_useDirectBuffers, chunkSize, 128, 2 );
+        m_cache = new ChunkCache( m_useDirectBuffers, chunkSize, 128 );
         m_chunkSize = chunkSize;
         m_chunk = m_cache.get();
     }
@@ -384,9 +367,4 @@ public final void clear( Logger logger )
     {
         m_cache.clear( logger );
     }
-
-    public final String clear()
-    {
-        return m_cache.clear();
-    }
 }

Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,8 @@ public abstract class ObjectCache<TYPE>`
`30`	`30`	`private final TYPE [] m_cache;`
`31`	`31`	`private int m_size;`
`32`	`32`	`private int m_gets;`
`33`		`- private int m_miss;`
`34`	`33`	`private int m_puts;`
	`34`	`+ private int m_miss;`
`35`	`35`
`36`	`36`	`protected abstract TYPE allocateObject();`
`37`	`37`
`@@ -86,22 +86,20 @@ public final TYPE get()`
`86`	`86`	`return allocateObject();`
`87`	`87`	`}`
`88`	`88`
`89`		`- public final void clear( Logger logger, int initialSize )`
	`89`	`+ public final void clear( Logger logger )`
`90`	`90`	`{`
`91`	`91`	`for (int idx=0; idx<m_size; idx++)`
`92`	`92`	`{`
`93`	`93`	`assert( m_cache[idx] != null );`
`94`	`94`	`m_cache[idx] = null;`
`95`	`95`	`}`
`96`	`96`
`97`		`- if (m_size < initialSize)`
	`97`	`+ if (m_puts != m_gets)`
`98`	`98`	`{`
`99`	`99`	`if (logger.isLoggable(Level.WARNING))`
`100`	`100`	`{`
`101`	`101`	`logger.log( Level.WARNING,`
`102`		`- m_name + ": resource leak detected: current size " +`
`103`		`- m_size + " less than initial size " + initialSize +`
`104`		`- " (get=" + m_gets + ", miss=" + m_miss + ", put=" + m_puts + ")." );`
	`102`	`+ m_name + ": resource leak detected: gets=" + m_gets + ", puts=" + m_puts + "." );`
`105`	`103`	`}`
`106`	`104`	`}`
`107`	`105`	`else`
`@@ -117,7 +115,7 @@ public final void clear( Logger logger, int initialSize )`
`117`	`115`	`m_size = 0;`
`118`	`116`	`}`
`119`	`117`
`120`		`- public final String clear( int initialSize )`
	`118`	`+ public String clear( int initialSize )`
`121`	`119`	`{`
`122`	`120`	`for (int idx=0; idx<m_size; idx++)`
`123`	`121`	`{`
`@@ -128,11 +126,11 @@ public final String clear( int initialSize )`
`128`	`126`	`final int size = m_size;`
`129`	`127`	`m_size = 0;`
`130`	`128`
`131`		`- if (size < initialSize)`
	`129`	`+ if (m_puts != m_gets)`
`132`	`130`	`{`
`133`	`131`	`return m_name + ": WARNING: resource leak detected: current size " +`
`134`	`132`	`size + " less than initial size " + initialSize +`
`135`		`- " (" + m_gets + ", " + m_miss + ", " + m_puts + ").";`
	`133`	`+ " (" + m_gets + ", " + m_miss + ", " + m_puts + ").";`
`136`	`134`	`}`
`137`	`135`	`else`
`138`	`136`	`{`
Original file line number	Diff line number	Diff line change
`@@ -123,12 +123,18 @@ public final boolean clearSafe()`
`123`	`123`	`return false;`
`124`	`124`	`}`
`125`	`125`
`126`		`- public RetainableByteBuffer slice()`
	`126`	`+ public final RetainableByteBuffer slice()`
`127`	`127`	`{`
`128`	`128`	`retain();`
`129`	`129`	`return new Slice( m_buf.slice() );`
`130`	`130`	`}`
`131`	`131`
	`132`	`+ public final RetainableByteBuffer duplicate()`
	`133`	`+ {`
	`134`	`+ retain();`
	`135`	`+ return new Slice( m_buf.duplicate() );`
	`136`	`+ }`
	`137`	`+`
`132`	`138`	`/*`
`133`	`139`	`* ByteBuffer interface mimic.`
`134`	`140`	`*/`
Original file line number	Diff line number	Diff line change
`@@ -23,38 +23,39 @@`
`23`	`23`
`24`	`24`	`public class RetainableByteBufferCache extends ObjectCache<RetainableByteBuffer>`
`25`	`25`	`{`
`26`		`- private class BufferImpl extends RetainableByteBufferImpl`
	`26`	`+ private static class BufferImpl extends RetainableByteBufferImpl`
`27`	`27`	`{`
`28`		`- public BufferImpl( ByteBuffer buf )`
	`28`	`+ private RetainableByteBufferCache m_cache;`
	`29`	`+`
	`30`	`+ public BufferImpl( ByteBuffer buf, RetainableByteBufferCache cache )`
`29`	`31`	`{`
`30`	`32`	`super( buf );`
	`33`	`+ m_cache = cache;`
`31`	`34`	`}`
`32`	`35`
`33`	`36`	`protected void finalRelease()`
`34`	`37`	`{`
`35`	`38`	`super.finalRelease();`
`36`		`- RetainableByteBufferCache.this.put( this );`
	`39`	`+ m_cache.put( this );`
`37`	`40`	`}`
`38`	`41`	`}`
`39`	`42`
`40`		`- private final int m_bufferCapacity;`
`41`	`43`	`private final boolean m_useDirectBuffer;`
	`44`	`+ private final int m_bufferCapacity;`
`42`	`45`
`43`	`46`	`protected BufferImpl allocateObject()`
`44`	`47`	`{`
`45`		`- final ByteBuffer buf =`
	`48`	`+ final ByteBuffer buf =`
`46`	`49`	`m_useDirectBuffer`
`47`	`50`	`? ByteBuffer.allocateDirect( m_bufferCapacity )`
`48`	`51`	`: ByteBuffer.allocate( m_bufferCapacity );`
`49`		`- return new BufferImpl( buf );`
	`52`	`+ return new BufferImpl( buf, this );`
`50`	`53`	`}`
`51`	`54`
`52`		`- public RetainableByteBufferCache( int bufferCapacity, boolean useDirectBuffer, int maxSize, int initialSize )`
	`55`	`+ public RetainableByteBufferCache( boolean useDirectBuffer, int bufferCapacity, int size )`
`53`	`56`	`{`
`54`		`- super( RetainableByteBuffer.class.getSimpleName() + "-" + bufferCapacity, new RetainableByteBuffer[maxSize] );`
`55`		`- m_bufferCapacity = bufferCapacity;`
	`57`	`+ super( RetainableByteBufferCache.class.getSimpleName() + "-" + bufferCapacity, new RetainableByteBuffer[size] );`
`56`	`58`	`m_useDirectBuffer = useDirectBuffer;`
`57`		`- for (int idx=0; idx<initialSize; idx++)`
`58`		`- put( allocateObject() );`
	`59`	`+ m_bufferCapacity = bufferCapacity;`
`59`	`60`	`}`
`60`	`61`	`}`