9:37 p.m.
Author: mircea.markus
Date: 2008-03-04 15:37:51 -0500 (Tue, 04 Mar 2008)
New Revision: 5385
Added:
core/trunk/src/test-perf/java/org/jboss/cache/LockMapPerformanceTest.java
Log:
test for benchmarking LockMap
Added: core/trunk/src/test-perf/java/org/jboss/cache/LockMapPerformanceTest.java
===================================================================
--- core/trunk/src/test-perf/java/org/jboss/cache/LockMapPerformanceTest.java
(rev 0)
+++ core/trunk/src/test-perf/java/org/jboss/cache/LockMapPerformanceTest.java 2008-03-04
20:37:51 UTC (rev 5385)
@@ -0,0 +1,212 @@
+package org.jboss.cache;
+
+import org.jboss.cache.lock.LockMap;
+import org.jboss.cache.util.concurrent.ConcurrentHashSet;
+
+import java.util.*;
+
+import junit.framework.TestCase;
+
+/**
+ * Class that tests LockMap performances on various access patterns and internal
implementation of readers array.
+ * Following access patterns on readers array were identified:
+ * <pre>
+ * - add to the end of the collection
+ * - remove(object); in other words random removals
+ * - contains (element)
+ * - (less frequnetly used) obtain the collection of readers and iterate over its
+ * </pre>
+ * todo - add a test to simulate concurrency (30% addition, 30%removals, 30% search and
10% iteration over the elements)
+ * @author Mircea.Markus(a)jboss.com
+ */
+public class LockMapPerformanceTest extends TestCase
+{
+
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+ configs = new Collection[4];
+ configs[0] = new Vector<Object>();
+ configs[1] = Collections.synchronizedList(new ArrayList<Object>());
+ configs[2] = Collections.synchronizedList(new LinkedList<Object>());
+ configs[3] = new ConcurrentHashSet<Object>();
+ }
+
+ Collection<Object>[] configs;
+ int[] readersSize = {10000};
+ int repeatCount = 100;
+
+
+ public void testPlainRead()
+ {
+ for (int size : readersSize)
+ {
+ Object[] objectPool = createObjectPool(size);
+ Object[] shuffledPool = shufflePool(objectPool);
+ for (Collection<Object> col : configs)
+ {
+ LockMap lockMap = new LockMap(col);
+ String benchDescription = "[" + col.getClass().getName() + ",
" + size + "]";
+ benchmarkAddition(objectPool, lockMap, benchDescription);
+ benchmarkSearch(lockMap, shuffledPool, benchDescription);
+ benchmarkRemoval(lockMap, shuffledPool, benchDescription);
+ }
+ }
+ }
+
+ private void benchmarkRemoval(LockMap lockMap, Object[] shuffledPool, String
benchDescription)
+ {
+ long start = System.currentTimeMillis();
+ for (Object anObjectPool : shuffledPool)
+ {
+ lockMap.removeReader(anObjectPool);
+ }
+ long durration = System.currentTimeMillis() - start;
+ log("removal", durration, benchDescription);
+ }
+
+ private void benchmarkSearch(LockMap lockMap, Object[] shuffledPool, String
benchDescription)
+ {
+ long start = System.currentTimeMillis();
+ for (Object anObjectPool : shuffledPool)
+ {
+ lockMap.isOwner(anObjectPool, LockMap.OWNER_READ);
+ }
+ long durration = System.currentTimeMillis() - start;
+ log("search", durration, benchDescription);
+ }
+
+ private void benchmarkAddition(Object[] objectPool, LockMap lockMap, String
benchDescription)
+ {
+ long start = System.currentTimeMillis();
+ for (Object anObjectPool : objectPool)
+ {
+ lockMap.addReader(anObjectPool);
+ }
+ long durration = System.currentTimeMillis() - start;
+ log("addition", durration, benchDescription);
+ }
+
+ private void log(String s, long durration, String benchDescription)
+ {
+ System.out.println(benchDescription + " - " + s + " - " +
durration + " millis ");
+ }
+
+ private Object[] shufflePool(Object[] objectPool)
+ {
+ List objects = Arrays.asList(objectPool);
+ Collections.shuffle(objects);
+ return objects.toArray();
+ }
+
+ private Object[] createObjectPool(int size)
+ {
+ Object[] result = new Object[size];
+ for (int i = 0; i < size; i++)
+ {
+ result[i] = new Object();
+ }
+ return result;
+ }
+
+ int threadCount = 10;
+ int[] operationPercentage = {30, 60, 90, 100}; //additions, removals, searches,
iterations
+ int poolSize = 10;
+ int operationCount = 1000;
+ public void testConcurrnecy() throws InterruptedException
+ {
+ LockMap lm = new LockMap(Collections.synchronizedList(new LinkedList()));
+ Object[] objectPool = createObjectPool(poolSize);
+ Object mutex = new Object();
+ Accessor[] accessors = new Accessor[threadCount];
+ for (int i = 0; i < threadCount; i++)
+ {
+ accessors[i] = new Accessor(lm,objectPool,mutex);
+ accessors[i].start();
+ }
+ Thread.sleep(1000);
+ long start = System.currentTimeMillis();
+ synchronized (mutex)
+ {
+ mutex.notifyAll();
+ }
+ for (int i = 0; i < threadCount; i++)
+ {
+ try
+ {
+ accessors[i].join();
+ } catch (InterruptedException e)
+ {
+ e.printStackTrace();
+ }
+ }
+ long durration = System.currentTimeMillis() - start;
+ System.out.println("Total durration is: " + durration);
+ }
+
+ class Accessor extends Thread
+ {
+ Random rnd = new Random();
+ LockMap lockMap;
+ Object[] objectPool;
+ Object mtex;
+
+ Accessor( LockMap lockMap, Object[] objectPool, Object mtex)
+ {
+ this.lockMap = lockMap;
+ this.objectPool = objectPool;
+ this.mtex = mtex;
+ }
+
+ int iterations;// just to avoid compiler optimizing the code
+ public void run()
+ {
+ try
+ {
+ synchronized (mtex)
+ {
+ mtex.wait();
+ }
+ } catch (InterruptedException e)
+ {
+ e.printStackTrace();
+ }
+ System.out.println("thread started");
+ for (int i =0 ; i < operationCount; i++)
+ {
+ int operation = getOperation();
+ switch (operation) {
+ case 0: lockMap.addReader(objectPool[rnd.nextInt(poolSize)]); break;
+ case 1: lockMap.removeReader(objectPool[rnd.nextInt(poolSize)]); break;
+ case 2: lockMap.isOwner(objectPool[rnd.nextInt(poolSize)],
LockMap.OWNER_READ); break;
+ case 3:
+ {
+ for (Object obj: lockMap.readerOwners())
+ {
+ iterations ++;
+ }
+ break;
+ }
+ default:
+ {
+ throw new RuntimeException("Unknown operation :" +
operation);
+ }
+ }
+ }
+ }
+
+ private int getOperation()
+ {
+ int val = rnd.nextInt(100);
+ for (int i =0; i < operationPercentage.length; i++)
+ {
+ if (operationPercentage[i] > val)
+ {
+ return i;
+ }
+ }
+ throw new RuntimeException("Did not expect " + val);
+ }
+ }
+}
+