rajout de bench lié à la recherche (à retravailler)

java-benchmarker/src/main/java/com/invivoo/benchmarker/AbstractBenchmark.java

@@ -1,14 +1,29 @@
 package com.invivoo.benchmarker;
 
+import java.util.concurrent.Callable;
 import java.util.concurrent.TimeUnit;
 
 public abstract class AbstractBenchmark<V> implements Benchmark<V> {
+	final BenchValue values = new BenchValue();
+
+	public final void bench(final Object param) {
+		values.reset();
+		if (param != null) {
+			measure(new Callable<Object>() {
 
-	private long timeSpent;
-	private long memoryConsumed;
-	private long tempMemory;
+				public Object call() throws Exception {
+					init(param);
+					return null;
+				}
+			});
+		}
+		measure(this);
+	}
+
+	protected void init(Object param) {
+	}
 
-	public final void bench() {
+	private final void measure(Callable c) {
 		// ensuring mem is clean
 		Runtime runtime = Runtime.getRuntime();
 		runtime.gc();
@@ -18,7 +33,7 @@ public final void bench() {
 		long beginMem = runtime.totalMemory() - runtime.freeMemory();
 		Object res = null;
 		try {
-			res = call();
+			res = c.call();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
@@ -29,47 +44,51 @@ public final void bench() {
 		long endMem1 = runtime.totalMemory() - runtime.freeMemory();
 
 		// displaying
-		timeSpent = (endTime - beginTime);
-		memoryConsumed = -(beginMem - endMem0);
-		tempMemory = -(endMem1 - endMem0);
+		values.timeSpent += (endTime - beginTime);
+		values.memoryConsumed += -(beginMem - endMem0);
+		values.tempMemory += -(endMem1 - endMem0);
 	}
 
+
 	public long getTempMemory() {
-		return tempMemory;
+		return values.tempMemory;
 	}
 
 	public long getMemoryConsumed() {
-		return memoryConsumed;
+		return values.memoryConsumed;
 	}
 
 	public long getTimeSpent() {
-		return timeSpent;
+		return values.timeSpent;
 	}
 
 	public String getDisplayTimeSpent() {
-		if (TimeUnit.SECONDS.convert(timeSpent, TimeUnit.NANOSECONDS) > 0) {
-			long nbMillis = TimeUnit.MILLISECONDS.convert(timeSpent, TimeUnit.NANOSECONDS); 
+		if (TimeUnit.SECONDS.convert(values.timeSpent, TimeUnit.NANOSECONDS) > 0) {
+			long nbMillis = TimeUnit.MILLISECONDS.convert(values.timeSpent, TimeUnit.NANOSECONDS); 
 			return (nbMillis/1000) +"." + (nbMillis%1000)+" s";
-		} else if (TimeUnit.MILLISECONDS.convert(timeSpent, TimeUnit.NANOSECONDS) > 0) {
-			return (timeSpent/1000000) +"." +(timeSpent%1000000)+" ms";
+		} else if (TimeUnit.MILLISECONDS.convert(values.timeSpent, TimeUnit.NANOSECONDS) > 0) {
+			return (values.timeSpent/1000000) +"." +(values.timeSpent%1000000)+" ms";
 		} else {
-			return timeSpent +" ns";
+			return values.timeSpent +" ns";
 		}
 	}
 
 	@Override
 	public String toString() {
-		return "<"+getDescription()+" time="+" used memory="+memoryConsumed+" temp memory="+tempMemory;
-//		if (TimeUnit.SECONDS.convert(timeSpent, TimeUnit.NANOSECONDS) > 0) {
-//			long nbMillis = TimeUnit.MILLISECONDS.convert(timeSpent, TimeUnit.NANOSECONDS); 
-//			System.out.println("bench for " + benchmark.getDescription() + " time="+ (nbMillis/1000) +"." +(nbMillis%1000)+" s");
-//		} else if (TimeUnit.MILLISECONDS.convert(timeSpent, TimeUnit.NANOSECONDS) > 0) {
-//			System.out.println("bench for " + benchmark.getDescription() + " time="+ (timeSpent/1000000) +"." +(timeSpent%1000000)+" ms");
-//		} else {
-//			System.out.println("bench for " + benchmark.getDescription() + " time="+ timeSpent +" ns consumed");
-//		}
-//		System.out.println("bench for " + benchmark.getDescription() + " mem0="+memoryConsumed+" bytes consumed");
-//		System.out.println("bench for " + benchmark.getDescription() + " mem1="+(memoryConsumed - tempMemory)+" bytes consumed gc="+tempMemory+" bytes garbage collected");
-//		return display;
+		return "<"+getDescription()+" time="+" used memory="+values.memoryConsumed+" temp memory="+values.tempMemory;
+	}
+
+	final class BenchValue {
+		long timeSpent;
+		long memoryConsumed;
+		long tempMemory;
+
+		public void reset() {
+			timeSpent = 0;
+			memoryConsumed = 0;
+			tempMemory = 0;
+		}
+
+
 	}
 }

java-benchmarker/src/main/java/com/invivoo/benchmarker/BenchMarkTest.java

@@ -1,5 +1,8 @@
 package com.invivoo.benchmarker;
 
+import com.invivoo.benchmarker.search.MapSearchBenchmark;
+import com.invivoo.benchmarker.search.SimpleListSearchBenchmark;
+import com.invivoo.benchmarker.search.SortedListSearchBenchmark;
 import com.invivoo.benchmarker.string.StringBenchmark;
 import com.invivoo.benchmarker.string.StringBufferBenchmark;
 import com.invivoo.benchmarker.string.StringBuilderWithCharBenchmark;
@@ -8,30 +11,22 @@
 import com.invivoo.benchmarker.thread.SleepCallable;
 import com.invivoo.benchmarker.thread.ThreadBenchmark;
 
+//-agentlib:hprof=heap=sites,net=localhost:6060,doe=n
 public class BenchMarkTest {
 	public static void main(String[] args) {
+		//Runtime.getRuntime().traceInstructions(true);
+		//Runtime.getRuntime().traceMethodCalls(true);
+
 		try {
 			System.out.println("BenchMarkTest.main()");
 			//Thread.sleep(40000);
 
 			for (int i = 0; i < 3; i++) {
 				// ensuring mem is clean
 				Runtime.getRuntime().gc();
-				bench(new StringBenchmark(1000));
-				bench(new StringBufferBenchmark(1000, 1));
-				bench(new StringBufferBenchmark(1000, 1000));
-				bench(new StringBuilderWithStringBenchmark(1000, 1));
-				bench(new StringBuilderWithStringBenchmark(1000, 1000));
-				bench(new StringBuilderWithCharBenchmark(1000, 1));
-				bench(new StringBuilderWithCharBenchmark(1000, 1000));
-				bench(new ThreadBenchmark(1000, 1, new CounterCallable(1000)));
-				bench(new ThreadBenchmark(1000, 10, new CounterCallable(1000)));
-				bench(new ThreadBenchmark(1000, 100, new CounterCallable(1000)));
-				bench(new ThreadBenchmark(1000, 1000, new CounterCallable(1000)));
-				//bench(new ThreadBenchmark(100, 1, new SleepBenchmark(100)));
-				bench(new ThreadBenchmark(100, 10, new SleepCallable(100)));
-				bench(new ThreadBenchmark(100, 100, new SleepCallable(100)));
-				bench(new ThreadBenchmark(100, 1000, new SleepCallable(100)));
+				benchString();
+				benchThread();
+				benchSearch();
 				System.out.println("==================================================================");
 			}
 		} catch (Exception e) {
@@ -40,21 +35,52 @@ public static void main(String[] args) {
 		}
 	}	
 
+	private static void benchString() {
+		bench(new StringBenchmark(1000));
+		bench(new StringBufferBenchmark(1000, 1));
+		bench(new StringBufferBenchmark(1000, 1000));
+		bench(new StringBuilderWithStringBenchmark(1000, 1));
+		bench(new StringBuilderWithStringBenchmark(1000, 1000));
+		bench(new StringBuilderWithCharBenchmark(1000, 1));
+		bench(new StringBuilderWithCharBenchmark(1000, 1000));
+	}
+
+	private static void benchThread() {
+		bench(new ThreadBenchmark(1000, 1, new CounterCallable(1000)));
+		bench(new ThreadBenchmark(1000, 10, new CounterCallable(1000)));
+		bench(new ThreadBenchmark(1000, 100, new CounterCallable(1000)));
+		bench(new ThreadBenchmark(1000, 1000, new CounterCallable(1000)));
+		//bench(new ThreadBenchmark(100, 1, new SleepCallable(100)));
+		bench(new ThreadBenchmark(100, 10, new SleepCallable(100)));
+		bench(new ThreadBenchmark(100, 100, new SleepCallable(100)));
+		bench(new ThreadBenchmark(100, 1000, new SleepCallable(100)));
+	}
+
+	private static void benchSearch() {
+		Comparable [] content = new Integer[10000];
+		for (int i = 0; i < content.length; i++) {
+			// just to ensure this is not sorted for the simple list
+			content[i] = (i * 11) % content.length;
+		}
+		Integer unknown = new Integer(-1);
+		bench(new SimpleListSearchBenchmark(content, unknown));
+		bench(new SortedListSearchBenchmark(content, unknown));
+		bench(new MapSearchBenchmark(content, unknown));
+		bench(new SimpleListSearchBenchmark(unknown), content);
+		bench(new SortedListSearchBenchmark(unknown), content);
+		bench(new MapSearchBenchmark(unknown), content);
+	}
+
 	public static void bench(Benchmark<Object> benchmark) {
-		benchmark.bench();
+		bench(benchmark, null);
+	}
+
+	public static void bench(Benchmark<Object> benchmark, Object param) {
+		benchmark.bench(param);
 		System.out.println("BenchMarkTest.bench(0) :" + benchmark.getDescription()+" time="+benchmark.getDisplayTimeSpent()+" used memory="+benchmark.getMemoryConsumed()+" temp memory="+benchmark.getTempMemory());
 //		benchmark.bench();
 //		System.out.println("BenchMarkTest.bench(1) :" + benchmark.getDescription()+" time="+benchmark.getDisplayTimeSpent()+" used memory="+benchmark.getMemoryConsumed()+" temp memory="+benchmark.getTempMemory());
 //		benchmark.bench();
 //		System.out.println("BenchMarkTest.bench(2) :" + benchmark.getDescription()+" time="+benchmark.getDisplayTimeSpent()+" used memory="+benchmark.getMemoryConsumed()+" temp memory="+benchmark.getTempMemory());
 	}
-
-	public static String concat(String A, String B) {
-		return new StringBuffer(A).append(B).toString();
-	}
-
-	public static boolean testInstance(Object a, Class<Object> b) {
-		return a.getClass().isInstance(b);
-	}
-
 }

java-benchmarker/src/main/java/com/invivoo/benchmarker/Benchmark.java

@@ -3,7 +3,7 @@
 import java.util.concurrent.Callable;
 
 public interface Benchmark<V> extends Callable<V> {
-	public void bench();
+	public void bench(Object param);
 
 	String getDescription();
 

java-benchmarker/src/main/java/com/invivoo/benchmarker/SocketAgent.java

@@ -0,0 +1,37 @@
+package com.invivoo.benchmarker;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class SocketAgent {
+	public static void main(String[] args) {
+		ServerSocket serverSocket = null;
+		try {
+			serverSocket = new ServerSocket(6060);
+			while (true) {
+				System.out.println("SocketAgent.main() WAITING FOR CLIENT");
+				Socket clientSocket = serverSocket.accept();
+				System.out.println("SocketAgent.main() NEW CONNECTED CLIENT");
+				BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+				String line;
+				while ((line = in.readLine()) != null) {
+					System.out.println("SocketAgent.main() " + line);
+				}
+				System.out.println("SocketAgent.main() TERMINATED");
+			}
+		} catch (Throwable e) {
+			e.printStackTrace();
+			try {
+				if (serverSocket != null) {
+					serverSocket.close();
+				}
+			} catch (IOException e1) {
+				e1.printStackTrace();
+			}
+		}
+	}
+}

java-benchmarker/src/main/java/com/invivoo/benchmarker/search/MapSearchBenchmark.java

@@ -0,0 +1,33 @@
+package com.invivoo.benchmarker.search;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MapSearchBenchmark extends SearchBenchmark {
+	private final Map<Object, Object> l = new HashMap<Object, Object>();
+
+	public MapSearchBenchmark(Object unknown) {
+		super(unknown);
+	}	
+
+	public MapSearchBenchmark(Object[] content, Object unknown) {
+		super(unknown);
+		init(content);
+	}
+
+	@Override
+	protected void add(Object o) {
+		l.put(o, this);
+	}
+
+	@Override
+	protected boolean searchFor(Object object) {
+		return l.containsKey(object);
+	}
+
+
+	public String getDescription() {
+		return "MapSearchBenchmark(" + l.size() + ")";
+	}
+
+}

java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SearchBenchmark.java

@@ -0,0 +1,40 @@
+package com.invivoo.benchmarker.search;
+
+import com.invivoo.benchmarker.AbstractBenchmark;
+
+public abstract class SearchBenchmark extends AbstractBenchmark<Object> {
+	private Object[] content;
+	private final Object unknown;
+
+	public SearchBenchmark(Object unknown) {
+		this.unknown = unknown;
+	}
+
+	@Override
+	protected final void init(Object param) {
+		content = (Object[]) param;
+		for (int i = 0; i < content.length; i++) {
+			add(content[i]);
+		}
+	}
+
+	protected abstract void add(Object o);
+
+	public final Object call() throws Exception {
+		for (int i = 0; i < content.length; i++) {
+			boolean found = searchFor(content[i]);
+			if (! found) {
+				throw new RuntimeException();
+			}
+		}
+		for (int i = 0; i < content.length; i++) {
+			boolean found = searchFor(unknown);
+			if (found) {
+				throw new RuntimeException();
+			}
+		}
+		return null;
+	}
+
+	protected abstract boolean searchFor(Object object);
+}

java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SimpleListSearchBenchmark.java

@@ -0,0 +1,32 @@
+package com.invivoo.benchmarker.search;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SimpleListSearchBenchmark extends SearchBenchmark {
+	private final List<Object> l = new ArrayList<Object>();
+
+	public SimpleListSearchBenchmark(Object unknown) {
+		super(unknown);
+	}
+
+	public SimpleListSearchBenchmark(Object[] content, Object unknown) {
+		super(unknown);
+		init(content);
+	}
+
+	@Override
+	protected void add(Object o) {
+		l.add(o);
+	}
+
+	@Override
+	protected boolean searchFor(Object object) {
+		return l.contains(object);
+	}
+
+	public String getDescription() {
+		return "SimpleListSearchBenchmark(" + l.size() + ")";
+	}
+
+}