You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@directmemory.apache.org by ol...@apache.org on 2011/10/13 12:08:56 UTC
svn commit: r1182755 - in
/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache:
./ directmemory/ directmemory/cache/ directmemory/cache/test/
directmemory/memory/ directmemory/memory/test/ directmemory/preliminary/
directmemory/pre...
Author: olamy
Date: Thu Oct 13 10:08:55 2011
New Revision: 1182755
URL: http://svn.apache.org/viewvc?rev=1182755&view=rev
Log:
oups missed svn add
Added:
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheConcurrentTests.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheLightConcurrentTest.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/TestCachePlusSerialization.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/BaseTests.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests2.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests3.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MallocTests.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MemoryManagerTests.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/Starter.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/MicroBenchmarks.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/PreliminarBenchmarks.java (with props)
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/
incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/SerializerTest.java (with props)
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheConcurrentTests.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheConcurrentTests.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheConcurrentTests.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheConcurrentTests.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,211 @@
+package org.apache.directmemory.cache.test;
+
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.directmemory.cache.Cache;
+import org.directmemory.measures.Monitor;
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.MemoryManager;
+import org.directmemory.memory.Pointer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart()
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+
+public class CacheConcurrentTests {
+
+ private final static int entries = 100000;
+ public static AtomicInteger count = new AtomicInteger();
+ private static AtomicInteger got = new AtomicInteger();
+ private static AtomicInteger missed = new AtomicInteger();
+ private static AtomicInteger good = new AtomicInteger();
+ private static AtomicInteger bad = new AtomicInteger();
+ private static AtomicInteger read = new AtomicInteger();
+ private static AtomicInteger disposals = new AtomicInteger();
+
+ @BenchmarkOptions(benchmarkRounds = 10000, warmupRounds=0, concurrency=1000)
+ @Test
+ public void store() {
+ final String key = "test-" + count.incrementAndGet();
+ put(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 500, warmupRounds=0, concurrency=10)
+ @Test
+ public void storeSomeWithExpiry() {
+ final String key = "test-" + count.incrementAndGet();
+ putWithExpiry(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchThemAll() {
+ String key = "test-" + (rndGen.nextInt(entries)+1);
+ get(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchHalfOfThem() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+ get(key);
+ }
+
+ private void get(String key) {
+ Pointer p = Cache.getPointer(key);
+ @SuppressWarnings("unused")
+ byte [] check = Cache.retrieveByteArray(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = MemoryManager.retrieve(p);
+ if ((new String(payload)).startsWith(key))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ missed.incrementAndGet();
+ }
+ }
+
+ private void put(String key) {
+ final StringBuilder bldr = new StringBuilder();
+ for (int i = 0; i < 100; i++) {
+ bldr.append(key);
+ }
+ Cache.putByteArray(key,bldr.toString().getBytes());
+ }
+
+ private void putWithExpiry(String key) {
+ final StringBuilder bldr = new StringBuilder();
+ for (int i = 0; i < 100; i++) {
+ bldr.append(key);
+ }
+ Cache.putByteArray(key, bldr.toString().getBytes(), rndGen.nextInt(2000));
+ }
+
+
+ @BenchmarkOptions(benchmarkRounds = 50000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read8AndSomeDisposal() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ get(key);
+ break;
+ default:
+ final int rndVal = rndGen.nextInt(1000);
+ if ( rndVal > 995) {
+ disposals.incrementAndGet();
+ final long start = System.currentTimeMillis();
+ long howMany = MemoryManager.collectExpired();
+ final long end = System.currentTimeMillis();
+ logger.info("" + howMany + " disposed in " + (end-start) + " milliseconds");
+ }
+ }
+
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write3Read7() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ case 1:
+ case 2:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+ }
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read9() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+
+ }
+
+ }
+
+ Random rndGen = new Random();
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+
+ private static Logger logger = LoggerFactory.getLogger(CacheConcurrentTests.class);
+
+ @BeforeClass
+ public static void init() {
+ Cache.init(1, Ram.Mb(512));
+ Cache.dump();
+ }
+
+ @AfterClass
+ public static void dump() {
+
+ Cache.dump();
+ Monitor.dump("cache");
+
+ logger.info("************************************************");
+ logger.info("entries: " + entries);
+ logger.info("inserted: " + Cache.entries());
+ logger.info("reads: " + read);
+ logger.info("count: " + count);
+ logger.info("got: " + got);
+ logger.info("missed: " + missed);
+ logger.info("good: " + good);
+ logger.info("bad: " + bad);
+ logger.info("disposals: " + disposals);
+ logger.info("************************************************");
+ }
+
+}
+
+
+
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheConcurrentTests.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheConcurrentTests.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheLightConcurrentTest.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheLightConcurrentTest.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheLightConcurrentTest.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheLightConcurrentTest.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,221 @@
+package org.apache.directmemory.cache.test;
+
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.directmemory.cache.Cache;
+import org.directmemory.measures.Every;
+import org.directmemory.measures.Monitor;
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.MemoryManager;
+import org.directmemory.memory.Pointer;
+import org.josql.QueryExecutionException;
+import org.josql.QueryParseException;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart()
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+
+public class CacheLightConcurrentTest {
+
+ private final static int entries = 10000;
+ public static AtomicInteger count = new AtomicInteger();
+ private static AtomicInteger got = new AtomicInteger();
+ private static AtomicInteger missed = new AtomicInteger();
+ private static AtomicInteger good = new AtomicInteger();
+ private static AtomicInteger bad = new AtomicInteger();
+ private static AtomicInteger read = new AtomicInteger();
+ private static AtomicInteger disposals = new AtomicInteger();
+
+ @BenchmarkOptions(benchmarkRounds = 10000, warmupRounds=0, concurrency=100)
+ @Test
+ public void store() {
+ final String key = "test-" + count.incrementAndGet();
+ put(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 50, warmupRounds=0, concurrency=10)
+ @Test
+ public void storeSomeWithExpiry() {
+ final String key = "test-" + count.incrementAndGet();
+ putWithExpiry(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 100000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchThemAll() {
+ String key = "test-" + (rndGen.nextInt(entries)+1);
+ getAndRetrieve(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 100000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchHalfOfThem() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+ getAndRetrieve(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1, warmupRounds=0, concurrency=1)
+ @Test
+ public void LFUEviction() throws QueryParseException, QueryExecutionException {
+ Cache.collectAll();
+ }
+
+ private void getAndRetrieve(String key) {
+ Pointer p = Cache.getPointer(key);
+ @SuppressWarnings("unused")
+ byte [] check = Cache.retrieveByteArray(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = MemoryManager.retrieve(p);
+ if ((new String(payload)).startsWith(key))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ missed.incrementAndGet();
+ }
+ }
+
+ private void put(String key) {
+ final StringBuilder bldr = new StringBuilder();
+ for (int i = 0; i < 100; i++) {
+ bldr.append(key);
+ }
+ Cache.putByteArray(key,bldr.toString().getBytes());
+ }
+
+ private void putWithExpiry(String key) {
+ final StringBuilder bldr = new StringBuilder();
+ for (int i = 0; i < 100; i++) {
+ bldr.append(key);
+ }
+ Cache.putByteArray(key, bldr.toString().getBytes(), rndGen.nextInt(2000));
+ }
+
+
+ @BenchmarkOptions(benchmarkRounds = 5000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read8AndSomeDisposal() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ getAndRetrieve(key);
+ break;
+ default:
+ final int rndVal = rndGen.nextInt(100);
+ if ( rndVal > 98) {
+ disposals.incrementAndGet();
+ final long start = System.currentTimeMillis();
+ long howMany = MemoryManager.collectExpired();
+ final long end = System.currentTimeMillis();
+ logger.info("" + howMany + " disposed in " + (end-start) + " milliseconds");
+ }
+ }
+
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 100000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write3Read7() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ case 1:
+ case 2:
+ put(key);
+ break;
+ default:
+ getAndRetrieve(key);
+ break;
+ }
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 100000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read9() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ default:
+ getAndRetrieve(key);
+ break;
+
+ }
+
+ }
+
+ Random rndGen = new Random();
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+
+ private static Logger logger = LoggerFactory.getLogger(CacheLightConcurrentTest.class);
+
+ @BeforeClass
+ public static void init() {
+ Cache.init(1, Ram.Mb(128));
+ Cache.scheduleDisposalEvery(Every.seconds(1));
+ Cache.dump();
+ }
+
+ @AfterClass
+ public static void dump() {
+
+ Cache.dump();
+ Monitor.dump("cache");
+
+ logger.info("************************************************");
+ logger.info("entries: " + entries);
+ logger.info("inserted: " + Cache.entries());
+ logger.info("reads: " + read);
+ logger.info("count: " + count);
+ logger.info("got: " + got);
+ logger.info("missed: " + missed);
+ logger.info("good: " + good);
+ logger.info("bad: " + bad);
+ logger.info("disposals: " + disposals);
+ logger.info("************************************************");
+ }
+
+}
+
+
+
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheLightConcurrentTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/CacheLightConcurrentTest.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/TestCachePlusSerialization.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/TestCachePlusSerialization.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/TestCachePlusSerialization.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/TestCachePlusSerialization.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,56 @@
+package org.apache.directmemory.cache.test;
+
+import static org.junit.Assert.*;
+
+import java.util.Random;
+
+import org.directmemory.cache.Cache;
+import org.directmemory.measures.Monitor;
+import org.directmemory.measures.Ram;
+import org.directmemory.misc.DummyPojo;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+
+
+public class TestCachePlusSerialization {
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+ private static Logger logger = LoggerFactory.getLogger(TestCachePlusSerialization.class);
+
+ Random rnd = new Random();
+
+ @BeforeClass
+ public static void init() {
+ logger.info("test started");
+ Cache.init(1, Ram.Mb(100));
+ }
+
+ @AfterClass
+ public static void end() {
+ Cache.dump();
+ Monitor.dump();
+ logger.info("test ended");
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 50000, warmupRounds=0, concurrency=1)
+ @Test
+ public void basicBench() {
+
+ DummyPojo d = new DummyPojo("test-" + rnd.nextInt(100000), 1024 + rnd.nextInt(1024));
+ Cache.put(d.name, d);
+ DummyPojo d2 = (DummyPojo) Cache.retrieve(d.name);
+
+ assertEquals(d.name, d2.name);
+
+ }
+
+}
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/TestCachePlusSerialization.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/cache/test/TestCachePlusSerialization.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/BaseTests.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/BaseTests.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/BaseTests.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/BaseTests.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,191 @@
+package org.apache.directmemory.memory.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.Date;
+import java.util.Map;
+import java.util.Random;
+import java.util.zip.CRC32;
+import java.util.zip.Checksum;
+
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.OffHeapMemoryBuffer;
+import org.directmemory.memory.Pointer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.google.common.collect.Maps;
+
+public class BaseTests {
+// @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+ @Test
+ public void smokeTest() {
+ OffHeapMemoryBuffer mem = OffHeapMemoryBuffer.createNew(1 * 1024 * 1024);
+ logger.info("buffer size=" + mem.capacity());
+ assertNotNull(mem);
+
+ Random rnd = new Random();
+
+ int size = rnd.nextInt(10) * mem.capacity() / 100;
+
+ logger.info("size=" + size);
+
+ Pointer p = mem.store(new byte[size]);
+ assertNotNull(p);
+ assertEquals(size,p.end);
+ assertEquals(size, mem.used());
+ mem.free(p);
+ assertEquals(0, mem.used());
+ }
+
+
+
+
+ private static Logger logger = LoggerFactory.getLogger(MallocTests.class);
+ private static Random rnd = new Random();
+ final static Map<String, Byte> test = Maps.newHashMap();
+ private static int errors;
+
+ public long crc(String str) {
+ final Checksum checksum = new CRC32();
+
+ final byte bytes[] = str.getBytes();
+ checksum.update(bytes,0,bytes.length);
+ return checksum.getValue();
+ }
+
+ @BeforeClass
+ @AfterClass
+ public static void setup() {
+ rnd = new Random();
+// logger.info("off-heap allocated: " + Ram.inMb(mem.capacity()));
+// logger.info("off-heap used: " + Ram.inMb(mem.used()));
+ logger.info("test - size: " + test.size());
+ logger.info("test - errors: " + errors);
+ logger.info("heap - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("heap - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("heap - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ logger.info("************************************************");
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 10000, warmupRounds = 0, concurrency = 10)
+ @Test
+ public void anyDuplicates() {
+ String key = "test" + rnd.nextInt(100000);
+ if (test.containsKey(key)) {
+ logger.error("key " + key + " has already been used");
+ errors++;
+ }
+ test.put(key, (byte) 0);
+ }
+
+ @Test
+ public void aFewEntriesWithRead() {
+ OffHeapMemoryBuffer mem = OffHeapMemoryBuffer.createNew(100 * 1024 * 1024);
+ logger.info("total capacity=" + Ram.inMb(mem.capacity()));
+ assertNotNull(mem);
+ int howMany = 10000;
+ logger.info("payload size is variable");
+ logger.info("entries=" + howMany);
+ String test = "this is a nicely crafted test";
+ for (int i = 0; i < howMany; i++) {
+ final byte[] payload = (test + " - " + i).getBytes();
+ Pointer p = mem.store(payload);
+ final byte[] check = mem.retrieve(p);
+ assertNotNull(check);
+ assertEquals(test + " - " + i, new String(check));
+ long crc1 = OffHeapMemoryBuffer.crc32(payload);
+ long crc2 = OffHeapMemoryBuffer.crc32(check);
+ assertEquals(crc1, crc2);
+ }
+
+ logger.info("total used=" + Ram.inMb(mem.used()));
+ }
+
+ @Test
+ public void aFewEntriesWithCheck() {
+ OffHeapMemoryBuffer mem = OffHeapMemoryBuffer.createNew(10 * 1024 * 1024);
+ logger.info("total capacity=" + Ram.inMb(mem.capacity()));
+ assertNotNull(mem);
+ int howMany = 10;
+ logger.info("payload size is variable");
+ logger.info("entries=" + howMany);
+ String test = "this is a nicely crafted test";
+ Pointer lastP = null;
+ for (int i = 0; i < howMany; i++) {
+ byte[] payload = (test + " - " + i).getBytes();
+ Pointer p = mem.store(payload);
+ logger.info("p.start=" + p.start);
+ logger.info("p.end=" + p.end);
+ if (lastP != null) {
+ assertEquals(lastP.end +1, p.start);
+ }
+ assertEquals(p.end-p.start, payload.length);
+ lastP = p;
+ logger.info("---");
+ }
+
+ logger.info("total used=" + Ram.inMb(mem.used()));
+ }
+
+ @Test
+ public void checkExpiration() throws InterruptedException {
+ OffHeapMemoryBuffer mem = OffHeapMemoryBuffer.createNew(10 * 1024 * 1024);
+ assertNotNull(mem);
+ int size = 400;
+ int howMany = 5000;
+
+ logger.info("off-heap capacity=" + Ram.inMb(mem.capacity()));
+ logger.info("payload size=" + Ram.inKb(size));
+ logger.info("entries=" + howMany);
+
+ byte[] payload = new byte[size];
+ for (int i = 0; i < howMany; i++) {
+ mem.store(payload, 2000);
+ }
+
+ assertEquals(size*howMany, mem.used());
+
+ logger.info("entries with relative expiration=" + (howMany/2));
+ for (int i = 0; i < howMany/2; i++) {
+ mem.store(payload, 100);
+ }
+ assertEquals(size*howMany+size*howMany/2, mem.used());
+
+ logger.info("entries with absolute expiration=" + (howMany/2));
+ for (int i = 0; i < howMany/2; i++) {
+ mem.store(payload, new Date());
+ }
+ assertEquals(size*howMany*2, mem.used());
+ logger.info("total used=" + Ram.inMb(mem.used()));
+
+ Thread.sleep(500);
+
+ logger.info("calling disposeExpiredAbsolute");
+ mem.disposeExpiredAbsolute();
+ logger.info("total used=" + Ram.inMb(mem.used()));
+ assertEquals(size*howMany+size*howMany/2, mem.used());
+
+ logger.info("calling disposeExpiredRelative");
+ mem.disposeExpiredRelative();
+ logger.info("total used=" + Ram.inMb(mem.used()));
+ assertEquals(size*howMany, mem.used());
+
+ Thread.sleep(2000);
+
+ logger.info("calling disposeExpiredRelative again");
+ mem.disposeExpiredRelative();
+ logger.info("total used=" + Ram.inMb(mem.used()));
+ assertEquals(0, mem.used());
+
+ }
+}
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/BaseTests.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/BaseTests.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,180 @@
+package org.apache.directmemory.memory.test;
+
+import java.util.Random;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.OffHeapMemoryBuffer;
+import org.directmemory.memory.Pointer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+import com.google.common.collect.MapMaker;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart()
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+
+public class ConcurrentTests {
+
+ private final static int entries = 100000;
+ public static AtomicInteger count = new AtomicInteger();
+ private static AtomicInteger got = new AtomicInteger();
+ private static AtomicInteger missed = new AtomicInteger();
+ private static AtomicInteger good = new AtomicInteger();
+ private static AtomicInteger bad = new AtomicInteger();
+ private static AtomicInteger read = new AtomicInteger();
+ public static OffHeapMemoryBuffer mem = OffHeapMemoryBuffer.createNew(512 * 1024 * 1024);
+
+ public static ConcurrentMap<String, Pointer> map = new MapMaker()
+ .concurrencyLevel(4)
+ .initialCapacity(100000)
+ .makeMap();
+
+
+ @BenchmarkOptions(benchmarkRounds = 100000, warmupRounds=0, concurrency=100)
+ @Test
+ public void store() {
+ final String key = "test-" + count.incrementAndGet();
+ map.put(key, mem.store(key.getBytes()));
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchThemAll() {
+ String key = "test-" + (rndGen.nextInt(entries)+1);
+ Pointer p = map.get(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = mem.retrieve(p);
+ if (key.equals(new String(payload)))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ logger.info("did not find key " + key);
+ missed.incrementAndGet();
+ }
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchHalfOfThem() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+ Pointer p = map.get(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = mem.retrieve(p);
+ if (key.equals(new String(payload)))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ missed.incrementAndGet();
+ }
+ }
+
+ private void put(String key) {
+ map.put(key, mem.store(key.getBytes()));
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write3Read7() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ case 1:
+ case 2:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+
+ }
+
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read9() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+
+ }
+
+ }
+ private void get(String key) {
+ Pointer p = map.get(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = mem.retrieve(p);
+ if (key.equals(new String(payload)))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ missed.incrementAndGet();
+ }
+ }
+
+ Random rndGen = new Random();
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+
+ private static Logger logger = LoggerFactory.getLogger(ConcurrentTests.class);
+
+ @BeforeClass
+ @AfterClass
+ public static void dump() {
+ logger.info("off-heap allocated: " + Ram.inMb(mem.capacity()));
+ logger.info("off-heap used: " + Ram.inMb(mem.used()));
+ logger.info("heap - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("heap - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("heap - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ logger.info("************************************************");
+ logger.info("entries: " + entries);
+ logger.info("inserted: " + map.size());
+ logger.info("reads: " + read);
+ logger.info("count: " + count);
+ logger.info("got: " + got);
+ logger.info("missed: " + missed);
+ logger.info("good: " + good);
+ logger.info("bad: " + bad);
+ logger.info("************************************************");
+ }
+
+}
+
+
+
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests2.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests2.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests2.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests2.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,194 @@
+package org.apache.directmemory.memory.test;
+
+import java.util.Random;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.MemoryManager;
+import org.directmemory.memory.OffHeapMemoryBuffer;
+import org.directmemory.memory.Pointer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+import com.google.common.collect.MapMaker;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart()
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+
+public class ConcurrentTests2 {
+
+ private final static int entries = 100000;
+ public static AtomicInteger count = new AtomicInteger();
+ private static AtomicInteger got = new AtomicInteger();
+ private static AtomicInteger missed = new AtomicInteger();
+ private static AtomicInteger good = new AtomicInteger();
+ private static AtomicInteger bad = new AtomicInteger();
+ private static AtomicInteger read = new AtomicInteger();
+
+ public static ConcurrentMap<String, Pointer> map = new MapMaker()
+ .concurrencyLevel(4)
+ .initialCapacity(100000)
+ .makeMap();
+
+
+ @BenchmarkOptions(benchmarkRounds = 100000, warmupRounds=0, concurrency=100)
+ @Test
+ public void store() {
+ final String key = "test-" + count.incrementAndGet();
+ put(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchThemAll() {
+ String key = "test-" + (rndGen.nextInt(entries)+1);
+ Pointer p = map.get(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = MemoryManager.retrieve(p);
+ if (key.equals(new String(payload)))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ logger.info("did not find key " + key);
+ missed.incrementAndGet();
+ }
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchHalfOfThem() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+ Pointer p = map.get(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = MemoryManager.retrieve(p);
+ if (key.equals(new String(payload)))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ missed.incrementAndGet();
+ }
+ }
+
+ private void put(String key) {
+ map.put(key, MemoryManager.store(key.getBytes()));
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write3Read7() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ case 1:
+ case 2:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+
+ }
+
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read9() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+
+ }
+
+ }
+ private void get(String key) {
+ Pointer p = map.get(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = MemoryManager.retrieve(p);
+ if (key.equals(new String(payload)))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ missed.incrementAndGet();
+ }
+ }
+
+ Random rndGen = new Random();
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+
+ private static Logger logger = LoggerFactory.getLogger(ConcurrentTests2.class);
+
+ private static void dump(OffHeapMemoryBuffer mem) {
+ logger.info("off-heap - buffer: " + mem.bufferNumber);
+ logger.info("off-heap - allocated: " + Ram.inMb(mem.capacity()));
+ logger.info("off-heap - used: " + Ram.inMb(mem.used()));
+ logger.info("heap - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("heap - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("heap - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ logger.info("************************************************");
+ }
+
+ @BeforeClass
+ public static void init() {
+ MemoryManager.init(1, Ram.Mb(512));
+ }
+
+ @AfterClass
+ public static void dump() {
+
+ for (OffHeapMemoryBuffer mem : MemoryManager.buffers) {
+ dump(mem);
+ }
+
+ logger.info("************************************************");
+ logger.info("entries: " + entries);
+ logger.info("inserted: " + map.size());
+ logger.info("reads: " + read);
+ logger.info("count: " + count);
+ logger.info("got: " + got);
+ logger.info("missed: " + missed);
+ logger.info("good: " + good);
+ logger.info("bad: " + bad);
+ logger.info("************************************************");
+ }
+
+}
+
+
+
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests2.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests2.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests3.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests3.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests3.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests3.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,226 @@
+package org.apache.directmemory.memory.test;
+
+import java.util.Random;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.MemoryManager;
+import org.directmemory.memory.OffHeapMemoryBuffer;
+import org.directmemory.memory.Pointer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+import com.google.common.collect.MapMaker;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart()
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+
+public class ConcurrentTests3 {
+
+ private final static int entries = 100000;
+ public static AtomicInteger count = new AtomicInteger();
+ private static AtomicInteger got = new AtomicInteger();
+ private static AtomicInteger missed = new AtomicInteger();
+ private static AtomicInteger good = new AtomicInteger();
+ private static AtomicInteger bad = new AtomicInteger();
+ private static AtomicInteger read = new AtomicInteger();
+ private static AtomicInteger disposals = new AtomicInteger();
+
+ public static ConcurrentMap<String, Pointer> map = new MapMaker()
+ .concurrencyLevel(4)
+ .initialCapacity(100000)
+ .makeMap();
+
+
+ @BenchmarkOptions(benchmarkRounds = 100000, warmupRounds=0, concurrency=100)
+ @Test
+ public void store() {
+ final String key = "test-" + count.incrementAndGet();
+ put(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 500, warmupRounds=0, concurrency=10)
+ @Test
+ public void storeSomeWithExpiry() {
+ final String key = "test-" + count.incrementAndGet();
+ putWithExpiry(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchThemAll() {
+ String key = "test-" + (rndGen.nextInt(entries)+1);
+ get(key);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=100)
+ @Test
+ public void retrieveCatchHalfOfThem() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+ get(key);
+ }
+
+ private void get(String key) {
+ Pointer p = map.get(key);
+ read.incrementAndGet();
+ if (p != null) {
+ got.incrementAndGet();
+ byte [] payload = MemoryManager.retrieve(p);
+ if ((new String(payload)).startsWith(key))
+ good.incrementAndGet();
+ else
+ bad.incrementAndGet();
+ } else {
+ missed.incrementAndGet();
+ }
+ }
+
+ private void put(String key) {
+ final StringBuilder bldr = new StringBuilder();
+ for (int i = 0; i < 100; i++) {
+ bldr.append(key);
+ }
+ map.put(key, MemoryManager.store(bldr.toString().getBytes()));
+ }
+
+ private void putWithExpiry(String key) {
+ final StringBuilder bldr = new StringBuilder();
+ for (int i = 0; i < 100; i++) {
+ bldr.append(key);
+ }
+ map.put(key, MemoryManager.store(bldr.toString().getBytes(), rndGen.nextInt(2000)));
+ }
+
+
+ @BenchmarkOptions(benchmarkRounds = 50000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read8AndSomeDisposal() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ get(key);
+ break;
+ default:
+ final int rndVal = rndGen.nextInt(1000);
+ if ( rndVal > 995) {
+ disposals.incrementAndGet();
+ final long start = System.currentTimeMillis();
+ long howMany = MemoryManager.collectExpired();
+ final long end = System.currentTimeMillis();
+ logger.info("" + howMany + " disposed in " + (end-start) + " milliseconds");
+ }
+ }
+
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write3Read7() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ case 1:
+ case 2:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+ }
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1000000, warmupRounds=0, concurrency=10)
+ @Test
+ public void write1Read9() {
+ String key = "test-" + (rndGen.nextInt(entries*2)+1);
+
+ int what = rndGen.nextInt(10);
+
+ switch (what) {
+ case 0:
+ put(key);
+ break;
+ default:
+ get(key);
+ break;
+
+ }
+
+ }
+
+ Random rndGen = new Random();
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+
+ private static Logger logger = LoggerFactory.getLogger(ConcurrentTests3.class);
+
+ private static void dump(OffHeapMemoryBuffer mem) {
+ logger.info("off-heap - buffer: " + mem.bufferNumber);
+ logger.info("off-heap - allocated: " + Ram.inMb(mem.capacity()));
+ logger.info("off-heap - used: " + Ram.inMb(mem.used()));
+ logger.info("heap - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("heap - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("heap - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ logger.info("************************************************");
+ }
+
+ @BeforeClass
+ public static void init() {
+ MemoryManager.init(1, Ram.Mb(512));
+ }
+
+ @AfterClass
+ public static void dump() {
+
+ for (OffHeapMemoryBuffer mem : MemoryManager.buffers) {
+ dump(mem);
+ }
+
+ logger.info("************************************************");
+ logger.info("entries: " + entries);
+ logger.info("inserted: " + map.size());
+ logger.info("reads: " + read);
+ logger.info("count: " + count);
+ logger.info("got: " + got);
+ logger.info("missed: " + missed);
+ logger.info("good: " + good);
+ logger.info("bad: " + bad);
+ logger.info("disposals: " + disposals);
+ logger.info("************************************************");
+ }
+
+}
+
+
+
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests3.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/ConcurrentTests3.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MallocTests.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MallocTests.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MallocTests.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MallocTests.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,172 @@
+package org.apache.directmemory.memory.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.Random;
+import java.util.concurrent.ConcurrentMap;
+
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.OffHeapMemoryBuffer;
+import org.directmemory.memory.Pointer;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+import com.google.common.collect.MapMaker;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart()
+@BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 0)
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+
+public class MallocTests {
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+ Random rnd = new Random();
+
+ private static Logger logger = LoggerFactory.getLogger(MallocTests.class);
+
+ @After
+ public void dump() {
+ logger.info("off-heap allocated: " + Ram.inMb(mem.capacity()));
+ logger.info("off-heap used: " + Ram.inMb(mem.used()));
+ logger.info("heap - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("heap - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("heap - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ logger.info("************************************************");
+ }
+
+ OffHeapMemoryBuffer mem = OffHeapMemoryBuffer.createNew(512 * 1024 * 1024);
+
+ @Test
+ public void oneMillionEntries() {
+ assertNotNull(mem);
+ int howMany = 1000000;
+ int size = mem.capacity() / (howMany);
+ size -= size / 100 * 1;
+ logger.info("payload size=" + size);
+ logger.info("entries=" + howMany);
+
+ logger.info("starting...");
+
+ long start = System.currentTimeMillis();
+
+ byte[] payload = new byte[size];
+ for (int i = 0; i < howMany; i++) {
+ mem.store(payload);
+ }
+
+ logger.info("...done in " + (System.currentTimeMillis() - start) + " msecs.");
+ }
+
+ @Test
+ public void twoMillionEntries() {
+
+ assertNotNull(mem);
+ int howMany = 2000000;
+ int size = mem.capacity() / (howMany);
+ size -= size / 100 * 1;
+ logger.info("payload size=" + size);
+ logger.info("entries=" + howMany);
+
+ logger.info("starting...");
+ long start = System.currentTimeMillis();
+
+ byte[] payload = new byte[size];
+ for (int i = 0; i < howMany; i++) {
+ mem.store(payload);
+ }
+
+ logger.info("...done in " + (System.currentTimeMillis() - start) + " msecs.");
+ }
+
+ @Test
+ public void fiveMillionEntries() {
+
+ assertNotNull(mem);
+ int howMany = 5000000;
+ int size = mem.capacity() / (howMany);
+ size -= size / 100 * 1;
+ logger.info("payload size=" + size);
+ logger.info("entries=" + howMany);
+
+ logger.info("starting...");
+ long start = System.currentTimeMillis();
+
+ byte[] payload = new byte[size];
+ for (int i = 0; i < howMany; i++) {
+ mem.store(payload);
+ }
+
+ logger.info("...done in " + (System.currentTimeMillis() - start) + " msecs.");
+ }
+
+
+ @Test
+ public void withMap() {
+
+ ConcurrentMap<Long, Pointer> map = new MapMaker()
+ .concurrencyLevel(4)
+ .initialCapacity(500000)
+ .makeMap();
+
+ String str = "This is the string to store into the off-heap memory";
+
+ int size = str.length();
+ int howMany = 1000000;
+ byte[] payload = str.getBytes();
+
+ logger.info("adding " + howMany + " strings of " + size + " bytes...");
+ for (long i = 0; i < howMany; i++) {
+ Pointer p = mem.store(payload);
+ map.put(i, p);
+ }
+ logger.info("...done");
+
+ }
+
+ @Before
+ public void before(){
+ mem.clear();
+ }
+
+
+
+
+ @Test
+ public void oneMillionEntriesWithRead() {
+
+ logger.info("total capacity=" + Ram.inMb(mem.capacity()));
+ assertNotNull(mem);
+ int size = 400;
+ int howMany = 1000000;
+ logger.info("payload size=" + Ram.inKb(size));
+ logger.info("entries=" + howMany);
+ String test = "this is a nicely crafted test";
+ byte[] payload = test.getBytes();
+ for (int i = 0; i < howMany; i++) {
+ Pointer p = mem.store(payload);
+ byte[] check = mem.retrieve(p);
+ assertNotNull(check);
+ assertEquals(test, new String(check));
+ }
+
+ logger.info("total used=" + Ram.inMb(mem.used()));
+ }
+}
+
+
+
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MallocTests.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MallocTests.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MemoryManagerTests.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MemoryManagerTests.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MemoryManagerTests.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MemoryManagerTests.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,85 @@
+package org.apache.directmemory.memory.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.Map;
+import java.util.Random;
+
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.MemoryManager;
+import org.directmemory.memory.OffHeapMemoryBuffer;
+import org.directmemory.memory.Pointer;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.google.common.collect.Maps;
+
+public class MemoryManagerTests {
+// @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+
+ @BeforeClass
+ public static void init() {
+ logger.info("init");
+ MemoryManager.init(1, Ram.Mb(100));
+ }
+
+ @Test
+ public void smokeTest() {
+ Random rnd = new Random();
+ int size = rnd.nextInt(10) * (int)MemoryManager.capacity() / 100;
+ logger.info("payload size=" + Ram.inKb(size));
+ Pointer p = MemoryManager.store(new byte[size]);
+ logger.info("stored");
+ assertNotNull(p);
+ assertEquals(size,p.end);
+ assertEquals(size, MemoryManager.activeBuffer.used());
+ MemoryManager.free(p);
+ assertEquals(0, MemoryManager.activeBuffer.used());
+ logger.info("end");
+ }
+
+ byte[] payload = "012345678901234567890123456789012345678901234567890123456789".getBytes();
+
+ @Test
+ public void fillupTest() {
+ MemoryManager.clear();
+ logger.info("payload size=" + Ram.inKb(payload.length));
+ long howMany = (MemoryManager.capacity() / payload.length);
+ howMany=(howMany*90)/100;
+
+
+ for (int i = 0; i < howMany ; i++) {
+ Pointer p = MemoryManager.store(payload);
+ assertNotNull(p);
+ }
+
+ logger.info("" + howMany + " items stored");
+ }
+
+
+ @Test
+ public void readTest() {
+ for (OffHeapMemoryBuffer buffer : MemoryManager.buffers) {
+ for (Pointer ptr : buffer.pointers) {
+ if (!ptr.free) {
+ byte[] res = MemoryManager.retrieve(ptr);
+ assertNotNull(res);
+ assertEquals(new String(payload), new String(res));
+ }
+ }
+ }
+ }
+
+
+ private static Logger logger = LoggerFactory.getLogger(MallocTests.class);
+
+ final static Map<String, Byte> test = Maps.newHashMap();
+
+}
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MemoryManagerTests.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/MemoryManagerTests.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/Starter.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/Starter.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/Starter.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/Starter.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,98 @@
+package org.apache.directmemory.memory.test;
+
+import static org.junit.Assert.assertNotNull;
+
+import org.directmemory.measures.Ram;
+import org.directmemory.memory.MemoryManager;
+import org.directmemory.memory.OffHeapMemoryBuffer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Starter {
+
+ private static Logger logger = LoggerFactory.getLogger(MallocTests.class);
+
+ /**
+ * @param args
+ */
+ public static void main(String[] args) {
+
+ if (args.length < 3) {
+ System.out.println("DirectMemory (for real testers only!) - usage:");
+ System.out.println(" java -XX:MaxDirectMemorySize=XXXXm -XmxXXXXm -XmsXXXXm -jar dm-test.jar <buffers> <Mb for each buffer> <entries>");
+ return;
+ }
+
+ int buffers = new Integer(args[0]);
+ int mb = new Integer(args[1]);
+ int entries = new Integer(args[2]);
+
+ logger.info("buffers: " + buffers);
+ logger.info("mb: " + mb);
+ logger.info("entries: " + entries);
+
+ Starter starter = new Starter();
+ starter.rawInsertMultipleBuffers(buffers, mb, entries);
+ }
+
+ public void dump(OffHeapMemoryBuffer mem) {
+ logger.info("off-heap - buffer: " + mem.pointers.get(1).bufferNumber);
+ logger.info("off-heap - allocated: " + Ram.inMb(mem.capacity()));
+ logger.info("off-heap - used: " + Ram.inMb(mem.used()));
+ logger.info("heap - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("heap - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("heap - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ logger.info("************************************************");
+ }
+
+ public void rawInsert(int megabytes, int howMany) {
+ OffHeapMemoryBuffer mem = OffHeapMemoryBuffer.createNew(megabytes * 1024 * 1024);
+ assertNotNull(mem);
+ int size = mem.capacity() / (howMany);
+ size -= size / 100 * 1;
+ logger.info("payload size=" + size);
+ logger.info("entries=" + howMany);
+
+ logger.info("starting...");
+
+ long start = System.currentTimeMillis();
+
+ byte[] payload = new byte[size];
+ for (int i = 0; i < howMany; i++) {
+ mem.store(payload);
+ }
+
+ logger.info("...done in " + (System.currentTimeMillis() - start) + " msecs.");
+ logger.info("---------------------------------");
+ dump(mem);
+ }
+
+
+ public void rawInsertMultipleBuffers(int buffers, int megabytes, int howMany) {
+ MemoryManager.init(buffers, Ram.Mb(megabytes));
+ int size = (int)(MemoryManager.capacity() / (howMany));
+ size -= size / 100 * 1;
+ logger.info("payload size=" + size);
+ logger.info("entries=" + howMany);
+
+ logger.info("starting...");
+
+ long start = System.currentTimeMillis();
+
+ byte[] payload = new byte[size];
+ for (int i = 0; i < howMany; i++) {
+ MemoryManager.store(payload);
+ }
+
+ logger.info("...done in " + (System.currentTimeMillis() - start) + " msecs.");
+ logger.info("---------------------------------");
+
+ for (OffHeapMemoryBuffer buf : MemoryManager.buffers) {
+ dump(buf);
+ }
+ }
+
+
+
+
+}
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/Starter.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/memory/test/Starter.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/MicroBenchmarks.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/MicroBenchmarks.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/MicroBenchmarks.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/MicroBenchmarks.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,189 @@
+package org.apache.directmemory.preliminary.test;
+
+import java.nio.ByteBuffer;
+import java.util.Map;
+import java.util.concurrent.ConcurrentMap;
+
+import org.directmemory.measures.Ram;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+import com.google.common.collect.MapMaker;
+import com.google.common.collect.Maps;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart(filePrefix = "latest-microbench")
+@BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 0)
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+
+public class MicroBenchmarks {
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+
+
+ private static Logger logger = LoggerFactory.getLogger(MicroBenchmarks.class);
+
+
+ private int many = 3000000;
+ private int less = 300000;
+
+ @Before
+ public void cleanup() {
+ dump("Before cleanup");
+ //Runtime.getRuntime().gc();
+ //dump("After cleanup");
+ logger.info("************************************************");
+ }
+
+ private void dump(String message) {
+ logger.info(message);
+ logger.info("Memory - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("Memory - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("Memory - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ }
+
+ @Test
+ public void manySmallInHeapWithHashmap() {
+ final Map<String, byte[]> test = Maps.newHashMap();
+ final byte payload[] = new byte[450];
+ long ops = many;
+ for (int i = 0; i < ops; i++) {
+ final String key = "test-"+i;
+ test.put(key, payload.clone());
+ }
+ logger.info("many=" + ops);
+ logger.info("payload.length=" + payload.length);
+ logger.info("stored " + Ram.inMb(payload.length * ops));
+ }
+
+
+
+ @Test
+ public void manySmallInHeapWithMapMaker() {
+ final byte payload[] = new byte[450];
+ int ops = many;
+
+ logger.info("many=" + ops);
+ logger.info("payload.length=" + payload.length);
+ pumpTheHeap(ops, payload);
+
+ }
+
+ @Test
+ public void manySmallOffHeap() {
+
+ final byte payload[] = new byte[450];
+ int ops = many;
+
+ logger.info("many=" + ops);
+ logger.info("payload.length=" + payload.length);
+ pumpOffHeap(ops, payload);
+
+ }
+
+
+ @Test
+ public void lessButLargerOffHeap() {
+
+ final byte payload[] = new byte[5120];
+ int ops = less;
+
+ logger.info("less=" + ops);
+ logger.info("payload.length=" + payload.length);
+ pumpOffHeap(ops, payload);
+
+ }
+
+ @Test
+ public void lessButLargerInHeap() {
+
+ final byte payload[] = new byte[5120];
+ int ops = less;
+
+ logger.info("less=" + ops);
+ logger.info("payload.length=" + payload.length);
+ pumpTheHeap(ops, payload);
+
+ }
+
+ /*
+ *
+ *
+ * ExecutorService executor = Executors.newCachedThreadPool();
+Callable<Object> task = new Callable<Object>() {
+ public Object call() {
+ return something.blockingMethod();
+ }
+}
+Future<Object> future = executor.submit(task);
+try {
+ Object result = future.get(5, TimeUnit.SECONDS);
+} catch (TimeoutException ex) {
+ // handle the timeout
+} finally {
+ future.cancel(); // may or may not desire this
+}
+ */
+
+
+ private void pumpOffHeap(int ops, byte[] payload) {
+
+ ConcurrentMap<String, ByteBuffer> test = new MapMaker()
+ .concurrencyLevel(4)
+ .makeMap();
+
+ logger.info(Ram.inMb(ops*payload.length) + " in " + ops + " slices to store");
+
+ ByteBuffer bulk = ByteBuffer.allocateDirect(ops * payload.length);
+
+ double started = System.currentTimeMillis();
+
+ for (int i = 0; i < ops; i++) {
+ bulk.position(i*payload.length);
+ final ByteBuffer buf = bulk.duplicate();
+ buf.put(payload);
+ test.put("test-"+i, buf);
+ }
+
+ double finished = System.currentTimeMillis();
+
+ logger.info("done in " + (finished-started)/1000 + " seconds");
+
+ for (ByteBuffer buf : test.values()) {
+ buf.clear();
+ }
+ }
+
+ private void pumpTheHeap(int ops, byte[] payload) {
+
+ ConcurrentMap<String, byte[]> test = new MapMaker()
+ .concurrencyLevel(4)
+ .makeMap();
+
+ logger.info(Ram.inMb(ops*payload.length) + " in " + ops + " slices to store");
+
+ double started = System.currentTimeMillis();
+
+ for (int i = 0; i < ops; i++) {
+ test.put("test-"+i, payload.clone());
+ }
+
+ double finished = System.currentTimeMillis();
+
+ logger.info("done in " + (finished-started)/1000 + " seconds");
+ }
+
+
+}
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/MicroBenchmarks.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/MicroBenchmarks.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/PreliminarBenchmarks.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/PreliminarBenchmarks.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/PreliminarBenchmarks.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/PreliminarBenchmarks.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,205 @@
+package org.apache.directmemory.preliminary.test;
+
+import static org.junit.Assert.*;
+
+import java.nio.ByteBuffer;
+import java.util.Map;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+
+import org.directmemory.measures.Ram;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.AbstractBenchmark;
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.google.common.collect.MapMaker;
+import com.google.common.collect.Maps;
+
+public class PreliminarBenchmarks extends AbstractBenchmark {
+
+ private static Logger logger = LoggerFactory.getLogger(PreliminarBenchmarks.class);
+ final static byte payload[] = new byte[1024];
+
+// @Before
+// @After
+ public void cleanup() {
+ dump("Before cleanup");
+ Runtime.getRuntime().gc();
+ dump("After cleanup");
+ logger.info("************************************************");
+ }
+
+ private void dump(String message) {
+ logger.info(message);
+ logger.info("Memory - max: " + Ram.inMb(Runtime.getRuntime().maxMemory()));
+ logger.info("Memory - allocated: " + Ram.inMb(Runtime.getRuntime().totalMemory()));
+ logger.info("Memory - free : " + Ram.inMb(Runtime.getRuntime().freeMemory()));
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 5, warmupRounds = 0)
+ @Test
+ public void justMap() {
+ final Map<String, byte[]> test = Maps.newHashMap();
+ long ops = 100000;
+ for (int i = 0; i < ops; i++) {
+ final String key = "test-"+i;
+ test.put(key, payload.clone());
+ }
+ logger.info("stored " + Ram.inMb(payload.length * ops));
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 0)
+ @Test
+ public void oneMillionSmallWithDirectBuffersOneAllocation() {
+
+ logger.info("payload is " + payload.length + " bytes");
+ final byte payload[] = new byte[500];
+ int ops = 1000000;
+
+ pumpWithOneAllocation(ops, payload);
+
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 0)
+ @Test
+ public void lessButLargerWithDirectBuffersOneAllocation() {
+
+ logger.info("payload is " + payload.length + " bytes");
+ final byte payload[] = new byte[2048];
+ int ops = 210000;
+
+ pumpWithOneAllocation(ops, payload);
+
+ }
+
+
+ /*
+ *
+ *
+ * ExecutorService executor = Executors.newCachedThreadPool();
+Callable<Object> task = new Callable<Object>() {
+ public Object call() {
+ return something.blockingMethod();
+ }
+}
+Future<Object> future = executor.submit(task);
+try {
+ Object result = future.get(5, TimeUnit.SECONDS);
+} catch (TimeoutException ex) {
+ // handle the timeout
+} finally {
+ future.cancel(); // may or may not desire this
+}
+ */
+
+ @BenchmarkOptions(benchmarkRounds = 5, warmupRounds = 0)
+ @Test
+ public void withDirectBuffers150k() {
+
+ logger.info("payload is " + payload.length + " bytes");
+ int ops = 150000;
+
+ pump(ops);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 5, warmupRounds = 0)
+ @Test
+ public void withDirectBuffers180k() {
+
+ logger.info("payload is " + payload.length + " bytes");
+ int ops = 180000;
+
+ pump(ops);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 5, warmupRounds = 0)
+ @Test
+ public void withDirectBuffers150kAgain() {
+
+ logger.info("payload is " + payload.length + " bytes");
+ int ops = 150000;
+
+ pump(ops);
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 0)
+ @Test
+ public void testAllocation() {
+
+ logger.info("payload is " + payload.length + " bytes");
+ logger.info("allocating " + Ram.inMb(payload.length * 200000) );
+ ByteBuffer buf = ByteBuffer.allocateDirect(payload.length * 200000);
+ assertNotNull(buf);
+ logger.info("done");
+ }
+
+
+ private void pumpWithOneAllocation(int ops, byte[] payload) {
+
+ ConcurrentMap<String, ByteBuffer> test = new MapMaker()
+ .concurrencyLevel(4)
+ .maximumSize(ops)
+ .expireAfterWrite(10, TimeUnit.MINUTES)
+ .makeMap();
+
+ logger.info(Ram.inMb(ops*payload.length) + " in " + ops + " slices to store");
+
+ ByteBuffer bulk = ByteBuffer.allocateDirect(ops * payload.length);
+
+ double started = System.currentTimeMillis();
+
+ for (int i = 0; i < ops; i++) {
+ bulk.position(i*payload.length);
+ final ByteBuffer buf = bulk.duplicate();
+ buf.put(payload);
+ test.put("test-"+i, buf);
+ }
+
+ double finished = System.currentTimeMillis();
+
+ logger.info("done in " + (finished-started)/1000 + " seconds");
+
+ for (ByteBuffer buf : test.values()) {
+ buf.clear();
+ }
+ }
+
+ @BenchmarkOptions(benchmarkRounds = 5, warmupRounds = 0)
+ @Test
+ public void withDirectBuffers100k() {
+
+ logger.info("payload is " + payload.length + " bytes");
+ int ops = 100000;
+
+ pump(ops);
+ }
+
+ private void pump(int ops) {
+ ConcurrentMap<String, ByteBuffer> test = new MapMaker()
+ .concurrencyLevel(4)
+ .maximumSize(ops)
+ .expireAfterWrite(10, TimeUnit.MINUTES)
+ .makeMap();
+
+ logger.info(Ram.inMb(ops*payload.length) + " to store");
+
+ double started = System.currentTimeMillis();
+
+ for (int i = 0; i < ops; i++) {
+ ByteBuffer buf = ByteBuffer.allocateDirect(payload.length);
+ buf.put(payload);
+ test.put("test-"+i, buf);
+ }
+
+ double finished = System.currentTimeMillis();
+
+ logger.info("done in " + (finished-started)/1000 + " seconds");
+
+ for (ByteBuffer buf : test.values()) {
+ buf.clear();
+ }
+ }
+
+}
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/PreliminarBenchmarks.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/preliminary/test/PreliminarBenchmarks.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/SerializerTest.java
URL: http://svn.apache.org/viewvc/incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/SerializerTest.java?rev=1182755&view=auto
==============================================================================
--- incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/SerializerTest.java (added)
+++ incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/SerializerTest.java Thu Oct 13 10:08:55 2011
@@ -0,0 +1,80 @@
+package org.apache.directmemory.serialization.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.IOException;
+
+import org.directmemory.measures.Monitor;
+import org.directmemory.measures.Ram;
+import org.directmemory.misc.DummyPojo;
+import org.directmemory.serialization.ProtoStuffSerializerV1;
+import org.directmemory.serialization.ProtoStuffWithLinkedBufferSerializer;
+import org.directmemory.serialization.Serializer;
+import org.directmemory.serialization.StandardSerializer;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
+import com.carrotsearch.junitbenchmarks.BenchmarkRule;
+import com.carrotsearch.junitbenchmarks.annotation.AxisRange;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
+import com.carrotsearch.junitbenchmarks.annotation.BenchmarkMethodChart;
+import com.carrotsearch.junitbenchmarks.annotation.LabelType;
+
+@AxisRange(min = 0, max = 1)
+@BenchmarkMethodChart()
+@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 5)
+ @BenchmarkOptions(benchmarkRounds = 2, warmupRounds=1, concurrency=1)
+
+public class SerializerTest {
+
+ @Rule
+ public MethodRule benchmarkRun = new BenchmarkRule();
+
+ private static Logger logger=LoggerFactory.getLogger(SerializerTest.class);
+ private void testSerializer(String name, Serializer serializer, int size, int howMany) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
+ logger.info("begin " + serializer.getClass().toString());
+ Monitor stopWatch = Monitor.get("serializer." + name + "." + size + "bytes");
+ Monitor stopWatch2 = Monitor.get("deserializer." + name + "." + size + "bytes");
+ DummyPojo pojo = new DummyPojo("test", size);
+ for (int i = 0; i < howMany; i++) {
+ long split = stopWatch.start();
+ final byte[] array = serializer.serialize(pojo, pojo.getClass());
+ stopWatch.stop(split);
+ long split2 = stopWatch2.start();
+ DummyPojo check = (DummyPojo) serializer.deserialize(array, pojo.getClass());
+ stopWatch2.stop(split2);
+ assertNotNull("object has not been serialized", check);
+ assertEquals(pojo.name, check.name);
+ }
+ logger.info("end serialize " + serializer.getClass().toString() + "\r\n" + stopWatch.toString());
+ logger.info("end deserialize " + serializer.getClass().toString() + "\r\n" + stopWatch2.toString());
+ }
+
+ @Test
+ public void ProtostuffTest() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
+ testSerializer("protostuff-old", new ProtoStuffSerializerV1(), Ram.Kb(1), 20000);
+ testSerializer("protostuff-old", new ProtoStuffSerializerV1(), Ram.Kb(2), 20000);
+ testSerializer("protostuff-old", new ProtoStuffSerializerV1(), Ram.Kb(3), 20000);
+ testSerializer("protostuff-old", new ProtoStuffSerializerV1(), Ram.Kb(4), 20000);
+ }
+ @Test
+ public void ProtostuffV2Test() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
+ testSerializer("protostuff-new", new ProtoStuffWithLinkedBufferSerializer(), Ram.Kb(1), 20000);
+ testSerializer("protostuff-new", new ProtoStuffWithLinkedBufferSerializer(), Ram.Kb(2), 20000);
+ testSerializer("protostuff-new", new ProtoStuffWithLinkedBufferSerializer(), Ram.Kb(3), 20000);
+ testSerializer("protostuff-new", new ProtoStuffWithLinkedBufferSerializer(), Ram.Kb(4), 20000);
+ testSerializer("cinquantamila", new ProtoStuffWithLinkedBufferSerializer(), Ram.Kb(3), 50000);
+ }
+ @Test
+ public void StandardTest() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
+ testSerializer("java-serialization", new StandardSerializer(), Ram.Kb(1), 20000);
+ testSerializer("java-serialization", new StandardSerializer(), Ram.Kb(2), 20000);
+ testSerializer("java-serialization", new StandardSerializer(), Ram.Kb(3), 20000);
+ testSerializer("java-serialization", new StandardSerializer(), Ram.Kb(4), 20000);
+ }
+}
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/SerializerTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/directmemory/trunk/directmemory-cache/src/test/java/org/apache/directmemory/serialization/test/SerializerTest.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision