diff --git a/java-benchmarker/optim.2.docx b/java-benchmarker/optim.2.docx index ec68028..a56d5bf 100644 Binary files a/java-benchmarker/optim.2.docx and b/java-benchmarker/optim.2.docx differ diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/AbstractBenchmark.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/AbstractBenchmark.java index e678d56..6013866 100644 --- a/java-benchmarker/src/main/java/com/invivoo/benchmarker/AbstractBenchmark.java +++ b/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 implements Benchmark { + final BenchValue values = new BenchValue(); + + public final void bench(final Object param) { + values.reset(); + if (param != null) { + measure(new Callable() { - 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; + } + + } } \ No newline at end of file diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/BenchMarkTest.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/BenchMarkTest.java index 480f4d2..f31574e 100644 --- a/java-benchmarker/src/main/java/com/invivoo/benchmarker/BenchMarkTest.java +++ b/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,8 +11,12 @@ 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); @@ -17,21 +24,9 @@ public static void main(String[] args) { 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 benchmark) { - benchmark.bench(); + bench(benchmark, null); + } + + public static void bench(Benchmark 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 b) { - return a.getClass().isInstance(b); - } - } diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/Benchmark.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/Benchmark.java index afb7fad..ab4fb34 100644 --- a/java-benchmarker/src/main/java/com/invivoo/benchmarker/Benchmark.java +++ b/java-benchmarker/src/main/java/com/invivoo/benchmarker/Benchmark.java @@ -3,7 +3,7 @@ import java.util.concurrent.Callable; public interface Benchmark extends Callable { - public void bench(); + public void bench(Object param); String getDescription(); diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/SocketAgent.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/SocketAgent.java new file mode 100644 index 0000000..fce8602 --- /dev/null +++ b/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(); + } + } + } +} diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/MapSearchBenchmark.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/MapSearchBenchmark.java new file mode 100644 index 0000000..e86c264 --- /dev/null +++ b/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 l = new HashMap(); + + 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() + ")"; + } + +} diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SearchBenchmark.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SearchBenchmark.java new file mode 100644 index 0000000..f4ac880 --- /dev/null +++ b/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 { + 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); +} diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SimpleListSearchBenchmark.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SimpleListSearchBenchmark.java new file mode 100644 index 0000000..4387c86 --- /dev/null +++ b/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 l = new ArrayList(); + + 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() + ")"; + } + +} diff --git a/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SortedListSearchBenchmark.java b/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SortedListSearchBenchmark.java new file mode 100644 index 0000000..bd3d852 --- /dev/null +++ b/java-benchmarker/src/main/java/com/invivoo/benchmarker/search/SortedListSearchBenchmark.java @@ -0,0 +1,37 @@ +package com.invivoo.benchmarker.search; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class SortedListSearchBenchmark extends SearchBenchmark { + private final List> l = new ArrayList>(); + + public SortedListSearchBenchmark(Object unknown) { + super(unknown); + } + + public SortedListSearchBenchmark(Comparable[] content, Object unknown) { + super(unknown); + init(content); + } + + @Override + protected void add(Object o) { + int indexToAdd = Collections.binarySearch(l, o); + if (indexToAdd > 0) { + throw new RuntimeException(); + } + l.add(-indexToAdd-1, (Comparable) o); + } + + @Override + protected boolean searchFor(Object object) { + return Collections.binarySearch(l, object) >= 0; + } + + public String getDescription() { + return "SortedListSearchBenchmark(" + l.size() + ")"; + } + +}