Benchmarks - Versionsgeschichte

L-ectron-X am 28. März 2018 um 08:10 Uhr

2018-03-28T08:10:20Z

← Nächstältere Version		Version vom 28. März 2018, 08:10 Uhr
Zeile 1:		Zeile 1:
	[[Kategorie:Java]]		[[Kategorie:Tutorials (Java)]]
	[[Kategorie:Java-Codeschnipsel]]		[[Kategorie:Java-Codeschnipsel]]

Zeile 479:		Zeile 479:
	Max memory: 63MB		Max memory: 63MB
	</nowiki>		</nowiki>

			{{Fragen stellen}}

L-ectron-X am 8. März 2018 um 09:33 Uhr

2018-03-08T09:33:28Z

← Nächstältere Version		Version vom 8. März 2018, 09:33 Uhr
Zeile 8:		Zeile 8:
	Das Interface Bench:		Das Interface Bench:

	<syntaxhighlight="java">		<syntaxhighlight lang="java">
	/*		/*
	* Bench.java		* Bench.java
Zeile 55:		Zeile 55:
	Die abstrakte Klasse Bench:		Die abstrakte Klasse Bench:

	<syntaxhighlight="java">		<syntaxhighlight lang="java">
	/*		/*
	* AbstractBench.java		* AbstractBench.java
Zeile 92:		Zeile 92:
	Das Benchmarksystem QuickBench:		Das Benchmarksystem QuickBench:

	<syntaxhighlight="java">		<syntaxhighlight lang="java">
	/*		/*
	* QuickBench.java		* QuickBench.java
Zeile 312:		Zeile 312:
	Ein kleines Beispiel zum Traversieren einer Liste (NxM):		Ein kleines Beispiel zum Traversieren einer Liste (NxM):

	<syntaxhighlight="java">		<syntaxhighlight lang="java">
	Bench b0 = new Bench() {		Bench b0 = new Bench() {
	List<String> l = null;		List<String> l = null;
Zeile 344:		Zeile 344:
	Benutzung:		Benutzung:

	<syntaxhighlight="java">		<syntaxhighlight lang="java">
	...		...
	QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },		QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },
Zeile 389:		Zeile 389:
	Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):		Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):

	<syntaxhighlight="java">		<syntaxhighlight lang="java">
	/* fibonacci -> recursive */		/* fibonacci -> recursive */
	static class FibBench_Recursive extends AbstractBench {		static class FibBench_Recursive extends AbstractBench {
Zeile 453:		Zeile 453:
	Aufruf wie folgt:		Aufruf wie folgt:

	<syntaxhighlight="java">		<syntaxhighlight lang="java">
	public static void main(String[] args) {		public static void main(String[] args) {
	QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,		QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,

L-ectron-X am 8. März 2018 um 09:31 Uhr

2018-03-08T09:31:06Z

← Nächstältere Version		Version vom 8. März 2018, 09:31 Uhr
Zeile 2:		Zeile 2:
	[[Kategorie:Java-Codeschnipsel]]		[[Kategorie:Java-Codeschnipsel]]

	Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.		Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei [[Klasse\|Klassen]], nämlich dem eigentlichen System namens QuickBench und einer [[Schnittstelle]] namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen [[Objekt\|Objekten]] gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.

	Das System erhebt keinesfalls den Anspruch perfekt implementiert oder jetzt der neue Meilenstein in Sachen benchmarking zu sein. Falls jemandem Fehler auffallen oder konstruktive Kritik besteht, bitte einfach kommentieren.		Das System erhebt keinesfalls den Anspruch perfekt implementiert oder jetzt der neue Meilenstein in Sachen benchmarking zu sein. Falls jemandem Fehler auffallen oder konstruktive Kritik besteht, bitte einfach im [https://forum.byte-welt.net/c/byte-welt-projekte-projects/wiki Forum] kommentieren.

	Das Interface Bench:		Das Interface Bench:

	<~~code~~=java>		<syntaxhighlight="java">
	/*		/*
	* Bench.java		* Bench.java
Zeile 51:		Zeile 51:
	void execute(long lm);		void execute(long lm);
	}		}
			</syntaxhighlight>
	</~~code=java~~>

	Die abstrakte Klasse Bench:		Die abstrakte Klasse Bench:

	<~~code~~=java>		<syntaxhighlight="java">
	/*		/*
	* AbstractBench.java		* AbstractBench.java
Zeile 89:		Zeile 88:

	}		}
			</syntaxhighlight>
	</~~code=java~~>

	Das Benchmarksystem QuickBench:		Das Benchmarksystem QuickBench:

	<~~code~~=java>		<syntaxhighlight="java">
	/*		/*
	* QuickBench.java		* QuickBench.java
Zeile 310:		Zeile 308:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	Ein kleines Beispiel zum Traversieren einer Liste (NxM):		Ein kleines Beispiel zum Traversieren einer Liste (NxM):

	<~~code~~=java>		<syntaxhighlight="java">
	Bench b0 = new Bench() {		Bench b0 = new Bench() {
	List<String> l = null;		List<String> l = null;
Zeile 342:		Zeile 340:
	}		}
	};		};
	</~~code=java~~>		</syntaxhighlight>

	Benutzung:		Benutzung:

	<~~code~~=java>		<syntaxhighlight="java">
	...		...
	QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },		QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },
	new Bench[] { b0 });		new Bench[] { b0 });
	...		...
	</~~code=java~~>		</syntaxhighlight>

	Als Ergebnis erhält man folgendes:		Als Ergebnis erhält man folgendes:
Zeile 391:		Zeile 389:
	Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):		Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):

	<~~code~~=java>		<syntaxhighlight="java">
	/* fibonacci -> recursive */		/* fibonacci -> recursive */
	static class FibBench_Recursive extends AbstractBench {		static class FibBench_Recursive extends AbstractBench {
Zeile 451:		Zeile 449:
	}		}
	};		};
	</~~code=java~~>		</syntaxhighlight>

	Aufruf wie folgt:		Aufruf wie folgt:

	<~~code~~=java>		<syntaxhighlight="java">
	public static void main(String[] args) {		public static void main(String[] args) {
	QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,		QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,
	new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});		new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});
	}		}
	</~~code=java~~>		</syntaxhighlight>

	Als Ergebnis erhält man ungefähr folgende Ausgabe:		Als Ergebnis erhält man ungefähr folgende Ausgabe:

L-ectron-x am 8. August 2013 um 17:47 Uhr

2013-08-08T17:47:17Z

← Nächstältere Version		Version vom 8. August 2013, 17:47 Uhr
Zeile 1:		Zeile 1:
	[[Kategorie:Java]]		[[Kategorie:Java]]
			[[Kategorie:Java-Codeschnipsel]]

	Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.		Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.

Fastjack am 7. August 2013 um 15:50 Uhr

2013-08-07T15:50:06Z

← Nächstältere Version		Version vom 7. August 2013, 15:50 Uhr
Zeile 7:		Zeile 7:
	Das Interface Bench:		Das Interface Bench:

	<~~nowiki~~>		<code=java>
	/*		/*
	* Bench.java		* Bench.java
Zeile 51:		Zeile 51:
	}		}

	</~~nowiki~~>		</code=java>

	Die abstrakte Klasse Bench:		Die abstrakte Klasse Bench:

	<~~nowiki~~>		<code=java>
	/*		/*
	* AbstractBench.java		* AbstractBench.java
Zeile 89:		Zeile 89:
	}		}

	</~~nowiki~~>		</code=java>

	Das Benchmarksystem QuickBench:		Das Benchmarksystem QuickBench:

	<~~nowiki~~>		<code=java>
	/*		/*
	* QuickBench.java		* QuickBench.java
Zeile 309:		Zeile 309:
	}		}
	}		}
	</~~nowiki~~>		</code=java>

	Ein kleines Beispiel zum Traversieren einer Liste (NxM):		Ein kleines Beispiel zum Traversieren einer Liste (NxM):

	<~~nowiki~~>		<code=java>
	Bench b0 = new Bench() {		Bench b0 = new Bench() {
	List<String> l = null;		List<String> l = null;
Zeile 341:		Zeile 341:
	}		}
	};		};
	</~~nowiki~~>		</code=java>

	Benutzung:		Benutzung:

	<~~nowiki~~>		<code=java>
	...		...
	QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },		QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },
	new Bench[] { b0 });		new Bench[] { b0 });
	...		...
			</code=java>
	</~~nowiki~~>

	Als Ergebnis erhält man folgendes:		Als Ergebnis erhält man folgendes:
Zeile 391:		Zeile 390:
	Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):		Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):

	<~~nowiki~~>		<code=java>
	/* fibonacci -> recursive */		/* fibonacci -> recursive */
	static class FibBench_Recursive extends AbstractBench {		static class FibBench_Recursive extends AbstractBench {
Zeile 451:		Zeile 450:
	}		}
	};		};
	</~~nowiki~~>		</code=java>

	Aufruf wie folgt:		Aufruf wie folgt:

	<~~nowiki~~>		<code=java>
	public static void main(String[] args) {		public static void main(String[] args) {
	QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,		QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,
	new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});		new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});
	}		}
	</~~nowiki~~>		</code=java>

	Als Ergebnis erhält man ungefähr folgende Ausgabe:		Als Ergebnis erhält man ungefähr folgende Ausgabe:

Fastjack am 7. August 2013 um 14:50 Uhr

2013-08-07T14:50:57Z

← Nächstältere Version		Version vom 7. August 2013, 14:50 Uhr
Zeile 1:		Zeile 1:
			[[Kategorie:Java]]

	Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.		Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.

Fastjack: Die Seite wurde neu angelegt: „Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System …“

2013-08-07T14:42:42Z

Die Seite wurde neu angelegt: „Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System …“

Neue Seite

Ich poste mal ein absichtlich stark vereinfachtes und leicht zu bedienendes Benchmarkingsystem. Es basiert nur auf zwei Klassen, nämlich dem eigentlichen System namens QuickBench und einer Schnittstelle namens Bench, das den einzelnen Benchmark darstellt. Ich denke die Benutzung ist wirklich einfach. Benches, die auf einer Objektstruktur arbeiten und mit unterschiedlich vielen Objekten gebencht werden sollen sind ebenso möglich, wie Benches, die nur eine bestimmte Funktion messen sollen, z.B. fib oder fac() und Co.

Das System erhebt keinesfalls den Anspruch perfekt implementiert oder jetzt der neue Meilenstein in Sachen benchmarking zu sein. Falls jemandem Fehler auffallen oder konstruktive Kritik besteht, bitte einfach kommentieren.

Das Interface Bench:

<nowiki>
/*
* Bench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Schnittstelle beschreibt einen Benchmark.
*
* @author fastjack
* @version 1.0
*/
public interface Bench {

/**
* @return der Name.
*/
String getName();

/**
* setzt den Benchmark und alle Resourcen, die er benutzt in den Urzustand zurück.
*/
void reset();

/**
* Bereitet den Benchmark zur Ausführung vor.
*
* @param lm Parameter anhand dessen der Benchmark vorbereitet wird.
*/
void prepare(long lm);

/**
* Führt den Benchmark aus.
*
* @param lm Parameter anhand dessen der Benchmark ausgeführt wird.
*/
void execute(long lm);
}

</nowiki>

Die abstrakte Klasse Bench:

<nowiki>
/*
* AbstractBench.java
*
* 06.01.2011
*
* (c) fastjack
*/

package blog.benchmarking;

/**
* Diese Klasse stellt einen abstrakten Benchmark dar.
*
* @author fastjack
* @version 1.0
*/
public abstract class AbstractBench implements Bench {

@Override
public String getName() {
return this.getClass().getSimpleName();
}

@Override
public void prepare(long lm) {
}

@Override
public void reset() {
}

}

</nowiki>

Das Benchmarksystem QuickBench:

<nowiki>
/*
* QuickBench.java
*
* 03.06.2010
*
* (c) fastjack
*/

package blog.benchmarking;

import java.util.*;

/**
* Diese kleine Klasse soll ein einfaches Benchmarksystem darstellen.
*
* @author fastjack
* @version 1.0
*/
public class QuickBench {

private final static String headerNxMSep = "+---------------------------+----------+-------"
+ "-----+----------+----------+-----------------+-----------------+";
private final static String headerNxM = "| %-25s | %8s | %10s | %8s | %8s | %15s | %15s "
+ "|\n";
private final static String headerNxIntervallSep = "+---------------------------+----------"
+ "+------------+------------+----------+----------+-----------------+-------------"
+ "----+";
private final static String headerNxIntervall = "| %-25s | %8s | %10s | %10s | %8s | %8s | "
+ "%15s | %15s |\n";
private final static String patternNxM = "| %-25s | %,8d | %,10d | %,8d | %,8d | %,15d | "
+ "%,15d |\n";
private final static String patternNxMWNT = "| %-25s | %,8d | %,10d | %,8d | %,8d | %15s | "
+ "%15s |\n";
private final static String patternNxIntervall = "| %-25s | %,8d | %,10d | %,10d | %,8d | "
+ "%,8d | %,15d | %,15d |\n";
private final static String patternNxIntervallWNT = "| %-25s | %,8d | %,10d | %,10d | %,8d "
+ "| %,8d | %15s | %15s |\n";

private QuickBench() {
}

/**
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet. Bevor das Benchmarking
* gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch den
* Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Alle Benchmarks werden zu jedem Eintrag e in n i-mal (i <= e) wiederholt,
* jeweils mit einem Wert aus dem dem angegebenen Intervall.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
* @param ba Benchmarks.
*/
public static void benchNxIntervall(long minMs, long wm, long[] n, long mmin, long mmax,
Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxIntervallSep);
System.out.printf(headerNxIntervall, "Bench", "Rounds", "min", "max", "ms",
"ms (avg)", "nt", "nt (avg)");
System.out.println(headerNxIntervallSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
qb.executeIntervall(b, n, minMs, mmin, mmax);
}
System.out.println(headerNxIntervallSep);
qb.showInfo();
}

/**
* Führt Benchmarks, die z.B. einer Anzahl von Objekten basieren, aus. Der Benchmark
* wird zurerst zurückgesetzt und jeweils zu einem Wert aus m vorbereitet. Bevor das
* Benchmarking gestartet wird, wird ein warmup zu allen Benchmarks aufgerufen und wie durch
* den Parameter wm angegeben, wiederholt. Die Anzahl an Durchläufen wird im Feld n
* angegeben. Die Anzahl der Objekte im Feld m. Alle Benchmarks werden zu jedem Eintrag m0
* in m i-mal (i <= m0) durchlaufen und zu jedem Eintrag n0 in n j-mal (j <= n0)
* zu dem Wert m0 ausgeführt.
*
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param wm WarmUp-Iterationen.
* @param n Anzahl an Iterationen.
* @param m Anzahl an z.B. Objekten.
* @param ba Benchmarks.
*/
public static void benchNxM(long minMs, long wm, long[] n, long[] m, Bench[] ba) {
QuickBench qb = new QuickBench();
qb.warmup(ba, wm);
System.out.println(headerNxMSep);
System.out.printf(headerNxM, "Bench", "Rounds", "Objects", "ms", "ms (avg)",
"nt", "nt (avg)");
System.out.println(headerNxMSep);
for (int i = 0; i < ba.length; i++) {
Bench b = ba[i];
for (int ii = 0; ii < m.length; ii++) {
qb.execute(b, n, minMs, m[ii]);
}
}
System.out.println(headerNxMSep);
qb.showInfo();
}

/*
* Zeigt Informationen zum System an.
*/
private void showInfo() {
System.out.println("java version " + System.getProperty("java.version"));
System.out.println(System.getProperty("java.runtime.name") + "(build " +
System.getProperty("java.runtime.version") + ")");
System.out.println(System.getProperty("java.vm.name") + "(build "
+ System.getProperty("java.vm.version") + ", "
+ System.getProperty("java.vm.info") + ")");
System.out.println(System.getProperty("os.name") + "("
+ System.getProperty("os.version") + ") " + System.getProperty("os.arch"));
System.out.println("Max memory: " + Runtime.getRuntime().maxMemory() / (1024 * 1024)
+ "MB");
}

/*
* Führt ein warmup zu allen Benchmarks durch. Dabei werden die Benches jeweils mit den
* Werten 1 vorbereitet und ausgeführt.
*
* @param ba Benchmarks.
* @param n Anzahl an Durchläufen zum WarmUp.
*/
private void warmup(Bench[] ba, long n) {
for (int i = 0; i < n; i++) {
for (int ii = 0; ii < ba.length; ii++) {
Bench b = ba[ii];
b.reset();
b.prepare(1);
b.execute(1);
}
}
}

/*
* Führt Benchmarks, die auf Funktionen etc. aufbauen und einen numerischen Parameter
* als Eingabe benötigen, aus. Diese Parameter werden in einem Intervall angegeben. Der
* Benchmark wird zurerst zurückgesetzt aber nicht vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param mmin Minimum des Intervalls.
* @param mmax Maximum des Intervalls.
*/
private void executeIntervall(Bench b, long[] n, long minMs, long mmin, long mmax) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
for (long l = mmin; l < mmax; l++) {
b.reset();
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(l);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
}
if (ms < minMs) {
System.out.printf(patternNxIntervall, b.getName(), ln, mmin, mmax, ms, ms / ln,
nt, (nt / ln));
} else {
System.out.printf(patternNxIntervallWNT, b.getName(), ln, mmin, mmax, ms,
ms / ln, "...", "...");
}
}
}

/*
* Führt Benchmarks zu einem gegebenen Wert aus. Der Benchmark wird zurerst
* zurückgesetzt und zu dem Wert val vorbereitet.
*
* @param b Benchmark.
* @param n Iterationen.
* @param minMs minimale Millesekunden, bei denen Nanosekunden angezeigt werden.
* @param val Wert.
*/
private void execute(Bench b, long[] n, long minMs, long val) {
for (int i = 0; i < n.length; i++) {
long ln = n[i];
long ms = 0;
long nt = 0;
long ms0 = 0;
long nt0 = 0;
for (int ii = 0; ii < ln; ii++) {
b.reset();
b.prepare(val);
ms0 = -System.currentTimeMillis();
nt0 = -System.nanoTime();
b.execute(val);
nt0 += System.nanoTime();
ms0 += System.currentTimeMillis();
ms += ms0;
nt += nt0;
}
if (ms < minMs) {
System.out.printf(patternNxM, b.getName(), ln, val, ms, ms / ln, nt, (nt / ln));
} else {
System.out.printf(patternNxMWNT, b.getName(), ln, val, ms, ms / ln, "...",
"...");
}
}
}
}
</nowiki>

Ein kleines Beispiel zum Traversieren einer Liste (NxM):

<nowiki>
Bench b0 = new Bench() {
List<String> l = null;

@Override
public String getName() {
return "Traverse";
}

@Override
public void reset() {
l = new ArrayList<String>();
}

@Override
public void prepare(long lm) {
for (int i = 0; i < lm; i++) {
l.add(String.valueOf(i));
}
}

@Override
public void execute(long lm) {
for (int i = 0, n = l.size(); i < n; i++) {
String s = l.get(i);
}
}
};
</nowiki>

Benutzung:

<nowiki>
...
QuickBench.benchNxM(10, 50000, new long[] { 10, 100, 1000 }, new long[] { 10000, 100000 },
new Bench[] { b0 });
...

</nowiki>

Als Ergebnis erhält man folgendes:

<nowiki>
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | Objects | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Traverse ArrayList For | 10 | 10.000 | 0 | 0 | 1.945.638 | 194.563 |
| Traverse ArrayList For | 100 | 10.000 | 16 | 0 | ... | ... |
| Traverse ArrayList For | 1.000 | 10.000 | 171 | 0 | ... | ... |
| Traverse ArrayList For | 10 | 100.000 | 16 | 1 | ... | ... |
| Traverse ArrayList For | 100 | 100.000 | 109 | 1 | ... | ... |
| Traverse ArrayList For | 1.000 | 100.000 | 1.170 | 1 | ... | ... |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>

Legende:

<nowiki>
Bench: Name des Benchmarks.
Rounds: Anzahl an Durchläufen.
Objects: Anzahl an verwendeteten Objekten.
ms: Gesamtzeitbedarf in Millisekunden.
ms (avg): Durchschnittlicher Zeitbedarf in Millisekunden.
nt: Gesamtzeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
nt (avg): Durchschnittlicher Zeitbedarf in Nanosekunden. Wenn ms > minMs wird hier nichts angezeigt.
</nowiki>

Weitere Beispiele folgen...

Und zwar jetzt:

Zwei Beispiele zu NxIntervall (Fibonacci rekursiv und nicht-rekursiv):

<nowiki>
/* fibonacci -> recursive */
static class FibBench_Recursive extends AbstractBench {

private int fib(int a) {
if (a == 1 || a == 2) {
return 1;
} else {
return fib(a - 1) + fib(a - 2);
}
}

@Override
public String getName() {
return "Fibonacci: recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};

/* fibonacci -> non-recursive */
static class FibBench_NonRecursive extends AbstractBench {

private long fib(int a) {
long fib = 1;
for (long fib1 = 1, fib2 = 1, i = 3; i <= a; i++) {
fib = fib1 + fib2;
fib1 = fib2;
fib2 = fib;
}
return fib;
}

@Override
public String getName() {
return "Fibonacci: non-recursive";
}

@Override
public void prepare(long lm) {
this.fib(1);
this.fib(2);
this.fib(3);
}

@Override
public void execute(long lm) {
this.fib((int) lm);
}
};
</nowiki>

Aufruf wie folgt:

<nowiki>
public static void main(String[] args) {
QuickBench.benchNxIntervall(10, 50000, new long[] { 10, 100, 1000}, 1, 25,
new Bench[]{new FibBench_Recursive(), new FibBench_NonRecursive()});
}
</nowiki>

Als Ergebnis erhält man ungefähr folgende Ausgabe:

<nowiki>
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Bench | Rounds | min | max | ms | ms (avg) | nt | nt (avg) |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
| Fibonacci: recursive | 10 | 1 | 25 | 0 | 0 | 8.312.579 | 831.257 |
| Fibonacci: recursive | 100 | 1 | 25 | 93 | 0 | ... | ... |
| Fibonacci: recursive | 1.000 | 1 | 25 | 812 | 0 | ... | ... |
| Fibonacci: non-recursive | 10 | 1 | 25 | 0 | 0 | 25.911 | 2.591 |
| Fibonacci: non-recursive | 100 | 1 | 25 | 0 | 0 | 241.581 | 2.415 |
| Fibonacci: non-recursive | 1.000 | 1 | 25 | 0 | 0 | 1.974.832 | 1.974 |
+---------------------------+----------+------------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_16
Java(TM) SE Runtime Environment(build 1.6.0_16-b01)
Java HotSpot(TM) Client VM(build 14.2-b01, mixed mode)
Windows Vista(6.0) x86
Max memory: 63MB
</nowiki>