incubator-directmemory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bperr...@apache.org
Subject svn commit: r1296133 - in /incubator/directmemory/trunk/directmemory-cache/src: main/java/org/apache/directmemory/memory/ main/java/org/apache/directmemory/memory/allocator/ test/java/org/apache/directmemory/memory/
Date Fri, 02 Mar 2012 10:55:57 GMT
Author: bperroud
Date: Fri Mar  2 10:55:57 2012
New Revision: 1296133

URL: http://svn.apache.org/viewvc?rev=1296133&view=rev
Log:
DIRECTMEMORY-40, DIRECTMEMORY-70 : augment testing, fix bug when clearing allocator and freeing
slab buffer

Added:
    incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/AbstractMemoryManagerServiceTest.java
    incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/DefaultMemoryManagerServiceTest.java
    incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/SlabMemoryManagerServiceTest.java
Modified:
    incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/MemoryManagerServiceImpl.java
    incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/AbstractByteBufferAllocator.java
    incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/FixedSizeByteBufferAllocatorImpl.java
    incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/MergingByteBufferAllocatorImpl.java

Modified: incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/MemoryManagerServiceImpl.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/MemoryManagerServiceImpl.java?rev=1296133&r1=1296132&r2=1296133&view=diff
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/MemoryManagerServiceImpl.java
(original)
+++ incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/MemoryManagerServiceImpl.java
Fri Mar  2 10:55:57 2012
@@ -207,6 +207,10 @@ public class MemoryManagerServiceImpl<V>
     @Override
     public void clear()
     {
+        for (Pointer<V> pointer : pointers)
+        {
+            pointer.setFree( true );
+        }
         pointers.clear();
         for (ByteBufferAllocator allocator : allocators)
         {

Modified: incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/AbstractByteBufferAllocator.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/AbstractByteBufferAllocator.java?rev=1296133&r1=1296132&r2=1296133&view=diff
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/AbstractByteBufferAllocator.java
(original)
+++ incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/AbstractByteBufferAllocator.java
Fri Mar  2 10:55:57 2012
@@ -1,5 +1,6 @@
 package org.apache.directmemory.memory.allocator;
 
+import java.nio.ByteBuffer;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.slf4j.Logger;
@@ -60,4 +61,9 @@ public abstract class AbstractByteBuffer
         this.closed.set( closed );
     }
     
+    protected static Integer getHash( final ByteBuffer buffer )
+    {
+        return Integer.valueOf( System.identityHashCode( buffer ) );
+    }
+    
 }

Modified: incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/FixedSizeByteBufferAllocatorImpl.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/FixedSizeByteBufferAllocatorImpl.java?rev=1296133&r1=1296132&r2=1296133&view=diff
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/FixedSizeByteBufferAllocatorImpl.java
(original)
+++ incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/FixedSizeByteBufferAllocatorImpl.java
Fri Mar  2 10:55:57 2012
@@ -23,6 +23,7 @@ import java.nio.BufferOverflowException;
 import java.nio.ByteBuffer;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -53,9 +54,6 @@ public class FixedSizeByteBufferAllocato
     // Total size of the current slab
     private int totalSize;
 
-    // Tells if one need to keep track of borrowed buffers
-    private boolean keepTrackOfUsedSliceBuffers = false;
-    
     // Tells if it returns null or throw an BufferOverflowException when the requested size
is bigger than the size of the slices
     private boolean returnNullWhenOversizingSliceSize = true;
     
@@ -63,8 +61,7 @@ public class FixedSizeByteBufferAllocato
     private boolean returnNullWhenNoBufferAvailable = true;
 
     // Collection that keeps track of borrowed buffers
-    private final Set<ByteBuffer> usedSliceBuffers = Collections
-        .newSetFromMap( new ConcurrentHashMap<ByteBuffer, Boolean>() );
+    private final Map<Integer, ByteBuffer> usedSliceBuffers = new ConcurrentHashMap<Integer,
ByteBuffer>();
 
     
     /**
@@ -74,7 +71,7 @@ public class FixedSizeByteBufferAllocato
      * @param sliceSize : arbitrary number of the buffer.
      * @param numberOfSegments : number of parent {@link ByteBuffer} to allocate.
      */
-    FixedSizeByteBufferAllocatorImpl( final int number, final int totalSize, final int sliceSize,
final int numberOfSegments )
+    public FixedSizeByteBufferAllocatorImpl( final int number, final int totalSize, final
int sliceSize, final int numberOfSegments )
     {
         super( number );
         
@@ -135,7 +132,7 @@ public class FixedSizeByteBufferAllocato
 
         checkState( !isClosed() );
         
-        if ( keepTrackOfUsedSliceBuffers && !usedSliceBuffers.remove( byteBuffer
) )
+        if ( usedSliceBuffers.remove( getHash( byteBuffer ) ) == null )
         {
             return;
         }
@@ -171,10 +168,7 @@ public class FixedSizeByteBufferAllocato
         allocatedByteBuffer.clear();
         allocatedByteBuffer.limit( size );
 
-        if ( keepTrackOfUsedSliceBuffers )
-        {
-            usedSliceBuffers.add( allocatedByteBuffer );
-        }
+        usedSliceBuffers.put( getHash( allocatedByteBuffer ), allocatedByteBuffer );
 
         return allocatedByteBuffer;
 
@@ -188,10 +182,11 @@ public class FixedSizeByteBufferAllocato
     @Override
     public void clear()
     {
-        if ( keepTrackOfUsedSliceBuffers )
+        for ( final Map.Entry<Integer, ByteBuffer> entry : usedSliceBuffers.entrySet()
)
         {
-            usedSliceBuffers.clear();
+            freeBuffers.offer( entry.getValue() );
         }
+        usedSliceBuffers.clear();
     }
 
     @Override

Modified: incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/MergingByteBufferAllocatorImpl.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/MergingByteBufferAllocatorImpl.java?rev=1296133&r1=1296132&r2=1296133&view=diff
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/MergingByteBufferAllocatorImpl.java
(original)
+++ incubator/directmemory/trunk/directmemory-cache/src/main/java/org/apache/directmemory/memory/allocator/MergingByteBufferAllocatorImpl.java
Fri Mar  2 10:55:57 2012
@@ -333,11 +333,6 @@ public class MergingByteBufferAllocatorI
         
         return newLinkedByteBuffer;
     }
-
-    private static Integer getHash( final ByteBuffer buffer )
-    {
-        return Integer.valueOf( System.identityHashCode( buffer ) );
-    }
     
     public void setSizeRatioThreshold( final double sizeRatioThreshold )
     {

Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/AbstractMemoryManagerServiceTest.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/AbstractMemoryManagerServiceTest.java?rev=1296133&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/AbstractMemoryManagerServiceTest.java
(added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/AbstractMemoryManagerServiceTest.java
Fri Mar  2 10:55:57 2012
@@ -0,0 +1,407 @@
+package org.apache.directmemory.memory;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import junit.framework.Assert;
+
+import org.apache.directmemory.memory.MemoryManagerService;
+import org.apache.directmemory.memory.MemoryTestUtils;
+import org.apache.directmemory.memory.Pointer;
+import org.junit.Test;
+
+public abstract class AbstractMemoryManagerServiceTest
+{
+
+    protected static final Random R = new Random();
+
+    protected static final int SMALL_PAYLOAD_LENGTH = 4;
+    protected static final byte[] SMALL_PAYLOAD = MemoryTestUtils.generateRandomPayload(
SMALL_PAYLOAD_LENGTH );
+
+
+	protected MemoryManagerService<Object> mms;
+	
+    protected abstract MemoryManagerService<Object> instanciateMemoryManagerService(
int bufferSize );
+
+
+    /**
+     * Test pointers allocation, when buffer size is not aligned with the size of stored
objects.
+     * Null {@link Pointer} should be returned to allow {@link MemoryManagerService} to go
to next step with allocation policy.
+     */
+    @Test
+    public void testNotEnoughFreeSpace()
+    {
+
+        // Storing a first payload of 4 bytes, 1 byte remaining in the buffer. When storing
a second 4 bytes payload, an null pointer should be returned.
+
+        final int BUFFER_SIZE = SMALL_PAYLOAD_LENGTH + 1;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        Pointer<Object> pointer1 = mms.store( SMALL_PAYLOAD );
+        Assert.assertNotNull( pointer1 );
+        Assert.assertFalse( pointer1.isFree() );
+
+        Pointer<Object> pointer2 = mms.store( SMALL_PAYLOAD );
+        Assert.assertNull( pointer2 );
+
+    }
+
+
+    /**
+     * Ensure no byte is leaking when allocating several objects.
+     */
+    @Test
+    public void testByteLeaking()
+    {
+
+        // Initializing 1 buffer of 10*4 bytes, should be able to allocate 10 objects of
4 bytes.
+
+        final int NUMBER_OF_OBJECTS = 10;
+        final int BUFFER_SIZE = NUMBER_OF_OBJECTS * SMALL_PAYLOAD_LENGTH;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        for ( int i = 0; i < NUMBER_OF_OBJECTS; i++ )
+        {
+            Pointer<Object> pointer = mms.store( SMALL_PAYLOAD );
+            Assert.assertNotNull( pointer );
+        }
+
+        Pointer<Object> pointerNull = mms.store( SMALL_PAYLOAD );
+        Assert.assertNull( pointerNull );
+    }
+
+    /**
+     * Ensure memory usage is reported correctly
+     */
+    @Test
+    public void testReportCorrectUsedMemory()
+    {
+
+        // Initializing 1 buffer of 4*4 bytes, storing and freeing and storing again should
report correct numbers.
+
+        final int NUMBER_OF_OBJECTS = 4;
+        final int BUFFER_SIZE = NUMBER_OF_OBJECTS * SMALL_PAYLOAD_LENGTH;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        Pointer<Object> lastPointer = null;
+        for ( int i = 0; i < NUMBER_OF_OBJECTS; i++ )
+        {
+            Pointer<Object> pointer = mms.store( SMALL_PAYLOAD );
+            Assert.assertNotNull( pointer );
+            lastPointer = pointer;
+        }
+
+        // Buffer is fully used.
+        Assert.assertEquals( BUFFER_SIZE, mms.used() );
+
+        Assert.assertNotNull( lastPointer );
+        mms.free( lastPointer );
+
+        Pointer<Object> pointerNotNull = mms.store( SMALL_PAYLOAD );
+        Assert.assertNotNull( pointerNotNull );
+
+        // Buffer again fully used.
+        Assert.assertEquals( BUFFER_SIZE, mms.used() );
+
+    }
+
+    /**
+     * Completely fill the buffer, free some pointer, reallocated the freed space, clear
the buffer. The entire space should be
+     */
+    @Test
+    public void testFullFillAndFreeAndClearBuffer()
+    {
+
+        final int NUMBER_OF_OBJECTS = 10;
+        final int BUFFER_SIZE = NUMBER_OF_OBJECTS * SMALL_PAYLOAD_LENGTH;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        Pointer<Object> pointerFull = mms.store( MemoryTestUtils.generateRandomPayload(
BUFFER_SIZE ) );
+        Assert.assertNotNull( pointerFull );
+        mms.free( pointerFull );
+
+        final int size1 = R.nextInt( BUFFER_SIZE / 2 ) + 1;
+        Pointer<Object> pointer1 = mms.store( MemoryTestUtils.generateRandomPayload(
size1 ) );
+        Assert.assertNotNull( "Cannot store " + size1 + " bytes", pointer1 );
+
+        final int size2 = R.nextInt( ( BUFFER_SIZE - size1 ) / 2 ) + 1;
+        Pointer<Object> pointer2 = mms.store( MemoryTestUtils.generateRandomPayload(
size2 ) );
+        Assert.assertNotNull( "Cannot store " + size2 + " bytes", pointer2 );
+
+        final int size3 = R.nextInt( ( BUFFER_SIZE - size1 - size2 ) / 2 ) + 1;
+        Pointer<Object> pointer3 = mms.store( MemoryTestUtils.generateRandomPayload(
size3 ) );
+        Assert.assertNotNull( "Cannot store " + size3 + " bytes", pointer3 );
+
+        final int size4 = BUFFER_SIZE - size1 - size2 - size3;
+        Pointer<Object> pointer4 = mms.store( MemoryTestUtils.generateRandomPayload(
size4 ) );
+        Assert.assertNotNull( "Cannot store " + size4 + " bytes", pointer4 );
+
+        mms.free( pointer1 );
+        Assert.assertTrue( pointer1.isFree() );
+
+        mms.free( pointer3 );
+
+        mms.free( pointer4 );
+
+        mms.free( pointer2 );
+
+        Assert.assertEquals( 0, mms.used() );
+
+        // As all pointers have been freeed, we should be able to reallocate the whole buffer
+        Pointer<Object> pointer6 = mms.store( MemoryTestUtils.generateRandomPayload(
BUFFER_SIZE ) );
+        Assert.assertNotNull( "Cannot store " + BUFFER_SIZE + " bytes", pointer6 );
+
+        mms.clear();
+
+        // As all pointers have been cleared, we should be able to reallocate the whole buffer
+        Pointer<Object> pointer7 = mms.store( MemoryTestUtils.generateRandomPayload(
BUFFER_SIZE ) );
+        Assert.assertNotNull( "Cannot store " + BUFFER_SIZE + " bytes", pointer7 );
+
+        mms.clear();
+
+        // As all pointers have been cleared, we should be able to reallocate the whole buffer
+        for ( int i = 0; i < NUMBER_OF_OBJECTS; i++ )
+        {
+            Pointer<Object> pointer = mms.store( SMALL_PAYLOAD );
+            Assert.assertNotNull( pointer );
+        }
+
+        mms.clear();
+
+        // As all pointers have been cleared, we should be able to reallocate the whole buffer
+        Pointer<Object> pointer8 = mms.store( MemoryTestUtils.generateRandomPayload(
BUFFER_SIZE ) );
+        Assert.assertNotNull( "Cannot store " + BUFFER_SIZE + " bytes", pointer8 );
+
+        mms.free( pointer8 );
+
+        // As all pointers have been cleared, we should be able to reallocate the whole buffer
+        for ( int i = 0; i < NUMBER_OF_OBJECTS * 10; i++ )
+        {
+            Pointer<Object> pointer = mms.store( SMALL_PAYLOAD );
+            Assert.assertNotNull( pointer );
+            mms.free( pointer );
+        }
+
+        // After a clear occurs, pointers allocated before the clear should be set as "free"
+        Assert.assertTrue( pointer6.isFree() );
+        Assert.assertTrue( pointer7.isFree() );
+
+    }
+
+    @Test
+    public void testRandomPayload()
+    {
+
+        final int NUMBER_OF_OBJECTS = 10;
+        final int BUFFER_SIZE = NUMBER_OF_OBJECTS * SMALL_PAYLOAD_LENGTH;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        for ( int i = 0; i < NUMBER_OF_OBJECTS; i++ )
+        {
+            byte[] payload = MemoryTestUtils.generateRandomPayload( SMALL_PAYLOAD_LENGTH
);
+            Pointer<Object> pointer = mms.store( payload );
+            Assert.assertNotNull( pointer );
+            byte[] fetchedPayload = mms.retrieve( pointer );
+            Assert.assertEquals( new String( payload ), new String( fetchedPayload ) );
+            if ( R.nextBoolean() )
+            {
+                mms.free( pointer );
+            }
+        }
+
+        mms.clear();
+
+        for ( int i = 0; i < NUMBER_OF_OBJECTS; i++ )
+        {
+            byte[] payload = MemoryTestUtils.generateRandomPayload( SMALL_PAYLOAD_LENGTH
);
+            Pointer<Object> pointer = mms.store( payload );
+            Assert.assertNotNull( pointer );
+            byte[] fetchedPayload = mms.retrieve( pointer );
+            Assert.assertEquals( new String( payload ), new String( fetchedPayload ) );
+            if ( R.nextBoolean() )
+            {
+                mms.free( pointer );
+                i--;
+            }
+        }
+
+    }
+
+    @Test
+    public void testStoreAllocAndFree()
+    {
+
+        final int NUMBER_OF_OBJECTS = 100;
+        final int BUFFER_SIZE = NUMBER_OF_OBJECTS * SMALL_PAYLOAD_LENGTH;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        List<Pointer<Object>> pointers = new ArrayList<Pointer<Object>>(
NUMBER_OF_OBJECTS );
+        for ( int i = 0; i < NUMBER_OF_OBJECTS; i++ )
+        {
+            byte[] payload = MemoryTestUtils.generateRandomPayload( SMALL_PAYLOAD_LENGTH
);
+            Pointer<Object> pointer = mms.store( payload );
+            Assert.assertNotNull( pointer );
+            pointers.add( pointer );
+            byte[] fetchedPayload = mms.retrieve( pointer );
+            Assert.assertEquals( new String( payload ), new String( fetchedPayload ) );
+        }
+
+        // Free 1/4 of the pointers, from 1/4 of the address space to 1/2
+        for ( int i = NUMBER_OF_OBJECTS / 4; i < NUMBER_OF_OBJECTS / 2; i++ )
+        {
+            Pointer<Object> pointer = pointers.get( i );
+            mms.free( pointer );
+        }
+
+        // Should be able to allocate NUMBER_OF_OBJECTS / 4 * SMALL_PAYLOAD_LENGTH bytes
+        Pointer<Object> pointer1 = mms.allocate( Object.class, NUMBER_OF_OBJECTS /
4 * SMALL_PAYLOAD_LENGTH, 0, 0 );
+        Assert.assertNotNull( pointer1 );
+
+        int pointerToSkip = NUMBER_OF_OBJECTS / 2 + NUMBER_OF_OBJECTS / 10;
+        for ( int i = NUMBER_OF_OBJECTS / 2; i < NUMBER_OF_OBJECTS * 3 / 4; i++ )
+        {
+            // skip one pointer
+            if ( i == pointerToSkip )
+            {
+                continue;
+            }
+            Pointer<Object> pointer = pointers.get( i );
+            mms.free( pointer );
+        }
+
+        // Should NOT be able to allocate NUMBER_OF_OBJECTS / 4 * SMALL_PAYLOAD_LENGTH bytes
+        Pointer<Object> pointer2 = mms.allocate( Object.class, NUMBER_OF_OBJECTS /
4 * SMALL_PAYLOAD_LENGTH, 0, 0 );
+        Assert.assertNull( pointer2 );
+
+        // Freeing the previously skipped pointer should then merge the whole memory space
+        mms.free( pointers.get( pointerToSkip ) );
+
+        // Should be able to allocate NUMBER_OF_OBJECTS / 4 * SMALL_PAYLOAD_LENGTH bytes
+        Pointer<Object> pointer3 = mms.allocate( Object.class, NUMBER_OF_OBJECTS /
4 * SMALL_PAYLOAD_LENGTH, 0, 0 );
+        Assert.assertNotNull( pointer3 );
+
+        byte[] payload3 = MemoryTestUtils.generateRandomPayload( NUMBER_OF_OBJECTS / 4 *
SMALL_PAYLOAD_LENGTH );
+        pointer3.getDirectBuffer().put( payload3 );
+        byte[] retrievePayload3 = mms.retrieve( pointer3 );
+        Assert.assertEquals( new String( payload3 ), new String( retrievePayload3 ) );
+
+    }
+
+    @Test
+    public void testUpdate()
+    {
+
+        final int NUMBER_OF_OBJECTS = 1;
+        final int BUFFER_SIZE = NUMBER_OF_OBJECTS * SMALL_PAYLOAD_LENGTH;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        final byte[] payload = MemoryTestUtils.generateRandomPayload( SMALL_PAYLOAD_LENGTH
);
+
+        final Pointer<Object> pointer = mms.store( payload );
+        Assert.assertNotNull( pointer );
+        Assert.assertEquals( new String( payload ), new String( mms.retrieve( pointer ) )
);
+
+        final byte[] otherPayload = MemoryTestUtils.generateRandomPayload( SMALL_PAYLOAD_LENGTH
);
+        final Pointer<Object> otherPointer = mms.update( pointer, otherPayload );
+        Assert.assertNotNull( otherPointer );
+        Assert.assertEquals( pointer.getStart(), otherPointer.getStart() );
+        Assert.assertEquals( pointer.getEnd(), otherPointer.getEnd() );
+        Assert.assertEquals( new String( otherPayload ), new String( mms.retrieve( otherPointer
) ) );
+
+        final byte[] evenAnotherPayload = MemoryTestUtils.generateRandomPayload( SMALL_PAYLOAD_LENGTH
/ 2 );
+        final Pointer<Object> evenAnotherPointer = mms.update( otherPointer, evenAnotherPayload
);
+        Assert.assertNotNull( evenAnotherPointer );
+        Assert.assertEquals( pointer.getStart(), evenAnotherPointer.getStart() );
+        Assert.assertEquals( pointer.getEnd(), evenAnotherPointer.getEnd() );
+        //Assert.assertEquals( 2, new String( mms.retrieve( evenAnotherPointer ) ).length()
);
+        Assert.assertTrue( new String( mms.retrieve( evenAnotherPointer ) )
+            .startsWith( new String( evenAnotherPayload ) ) );
+
+    }
+
+
+    @Test
+    public void testAllocate()
+    {
+
+        final int NUMBER_OF_OBJECTS = 10;
+        final int BUFFER_SIZE = NUMBER_OF_OBJECTS * SMALL_PAYLOAD_LENGTH;
+
+        mms = instanciateMemoryManagerService( BUFFER_SIZE );
+        
+        final byte[] payload1 = MemoryTestUtils.generateRandomPayload( 8 * SMALL_PAYLOAD_LENGTH
);
+        final Pointer<Object> pointer1 = mms.store( payload1 );
+        Assert.assertNotNull( pointer1 );
+        Assert.assertEquals( new String( payload1 ), new String( mms.retrieve( pointer1 )
) );
+
+        final byte[] payload2 = MemoryTestUtils.generateRandomPayload( 2 * SMALL_PAYLOAD_LENGTH
);
+        final Pointer<Object> pointer2 = mms.store( payload2 );
+        Assert.assertNotNull( pointer2 );
+        Assert.assertEquals( new String( payload2 ), new String( mms.retrieve( pointer2 )
) );
+
+        mms.free( pointer1 );
+
+        final byte[] payload3 = MemoryTestUtils.generateRandomPayload( 2 * SMALL_PAYLOAD_LENGTH
);
+        final Pointer<Object> pointer3 = mms.store( payload3 );
+        Assert.assertNotNull( pointer3 );
+        Assert.assertEquals( new String( payload3 ), new String( mms.retrieve( pointer3 )
) );
+
+        final int size1 = 4 * SMALL_PAYLOAD_LENGTH;
+        final byte[] allocatedPayload1 = MemoryTestUtils.generateRandomPayload( size1 );
+        final Pointer<Object> allocatedPointer1 = mms.allocate( Object.class, allocatedPayload1.length,
-1, -1 );
+        Assert.assertNotNull( allocatedPointer1 );
+        final ByteBuffer buffer1 = allocatedPointer1.getDirectBuffer();
+        Assert.assertNotNull( buffer1 );
+        Assert.assertEquals( 0, buffer1.position() );
+        Assert.assertEquals( size1, buffer1.limit() );
+        Assert.assertEquals( size1, buffer1.capacity() );
+        buffer1.put( allocatedPayload1 );
+        Assert.assertEquals( new String( allocatedPayload1 ), new String( mms.retrieve( allocatedPointer1
) ) );
+
+        final int size2 = 2 * SMALL_PAYLOAD_LENGTH;
+        final byte[] allocatedPayload2 = MemoryTestUtils.generateRandomPayload( size2 );
+        final Pointer<Object> allocatedPointer2 = mms.allocate( Object.class, allocatedPayload2.length,
-1, -1 );
+        Assert.assertNotNull( allocatedPointer2 );
+        final ByteBuffer buffer2 = allocatedPointer2.getDirectBuffer();
+        Assert.assertNotNull( buffer2 );
+        Assert.assertEquals( size2, buffer2.limit() );
+        Assert.assertEquals( size2, buffer2.capacity() );
+        buffer2.put( allocatedPayload2 );
+        Assert.assertEquals( new String( allocatedPayload2 ), new String( mms.retrieve( allocatedPointer2
) ) );
+
+
+        // Ensure the new allocation has not overwritten other data
+        Assert.assertEquals( new String( payload2 ), new String( mms.retrieve( pointer2 )
) );
+        Assert.assertEquals( new String( payload3 ), new String( mms.retrieve( pointer3 )
) );
+
+    }
+
+}

Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/DefaultMemoryManagerServiceTest.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/DefaultMemoryManagerServiceTest.java?rev=1296133&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/DefaultMemoryManagerServiceTest.java
(added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/DefaultMemoryManagerServiceTest.java
Fri Mar  2 10:55:57 2012
@@ -0,0 +1,15 @@
+package org.apache.directmemory.memory;
+
+public class DefaultMemoryManagerServiceTest
+    extends AbstractMemoryManagerServiceTest
+{
+
+    @Override
+    protected MemoryManagerService<Object> instanciateMemoryManagerService( int bufferSize
)
+    {
+        final MemoryManagerService<Object> mms = new MemoryManagerServiceImpl<Object>();
+        mms.init( 1, bufferSize );
+        return mms;
+    }
+
+}

Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/SlabMemoryManagerServiceTest.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/SlabMemoryManagerServiceTest.java?rev=1296133&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/SlabMemoryManagerServiceTest.java
(added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/SlabMemoryManagerServiceTest.java
Fri Mar  2 10:55:57 2012
@@ -0,0 +1,44 @@
+package org.apache.directmemory.memory;
+
+import java.util.Collection;
+import java.util.HashSet;
+
+import org.apache.directmemory.memory.allocator.ByteBufferAllocator;
+import org.apache.directmemory.memory.allocator.FixedSizeByteBufferAllocatorImpl;
+import org.apache.directmemory.memory.allocator.SlabByteBufferAllocatorImpl;
+import org.junit.Test;
+
+public class SlabMemoryManagerServiceTest
+    extends AbstractMemoryManagerServiceTest
+{
+
+    @Override
+    protected MemoryManagerService<Object> instanciateMemoryManagerService( int bufferSize
)
+    {
+        final MemoryManagerService<Object> mms = new MemoryManagerServiceImpl<Object>()
{
+
+            @Override
+            protected ByteBufferAllocator instanciateByteBufferAllocator( int allocatorNumber,
int size )
+            {
+                Collection<FixedSizeByteBufferAllocatorImpl> slabs = new HashSet<FixedSizeByteBufferAllocatorImpl>();
+                
+                slabs.add( new FixedSizeByteBufferAllocatorImpl(0, size, SMALL_PAYLOAD_LENGTH
/ 2, 1) );
+                slabs.add( new FixedSizeByteBufferAllocatorImpl(1, size, SMALL_PAYLOAD_LENGTH,
1) );
+                
+                final SlabByteBufferAllocatorImpl allocator = new SlabByteBufferAllocatorImpl(
allocatorNumber, slabs, false );
+                
+                return allocator;
+            }
+            
+        };
+        mms.init( 1, bufferSize );
+        return mms;
+    }
+
+    @Override
+    @Test
+    public void testFullFillAndFreeAndClearBuffer()
+    {
+        
+    }
+}



Mime
View raw message