A Programme
Benchmark
/** SMall JVM-Benchmark-Collection
* @version 1.1
* @author Marc Schanne <Marc.Schanne@stud.uni-karlsruhe.de>
*/
import java.applet.*;
import java.awt.*;
import java.io.*;
/** Benchmark ist eine abstrakte Klasse, die fuer konkrete
* Benchmark-Programme Methoden zur Zeitmessung, systemunabh.
* Ausgabe und Appletdarstellung zur Verfuegung stellt.
* runBenchmark() und infoBenchmark() muessen vom konkreten
* Testprogramm implementiert werden.
*/
public abstract class Benchmark extends Applet
// Variablen zur Zeitmessung und Ausgabe}
private long startTime, elapsedTime;
private Button runButton;
private TextArea textArea;}
// Applet oder Application?}
private boolean isApplet = false;
/** System- (d.h. von Applet oder Application)
* unabhaengige Ausgabe-Routine
*/
public void printBenchmark(String str) {
if (isApplet)
textArea.appendText(str + "\n");
else
System.out.println(str);
}
/** Zeitklammer oeffnen (d.h Startzeit speichern) */
public void beginBenchmark() {
System.gc();
printBenchmark("Die Uhr laeuft ...");
startTime = System.currentTimeMillis();
}
/** Zeitklammer schliessen und Laufzeit ausgeben */
public void endBenchmark() {
elapsedTime = System.currentTimeMillis() - startTime;
double seconds = elapsedTime / 1000.0;
printBenchmark{"... und stop. Laufzeit: " + seconds
+ " Sek.");
}
/** Der Test selbst;
* Ausgaben ueber die printBenchmark()-Methode
* Zeitmessung mit begin/endBenchmark()
*/
public abstract void runBenchmark();
/** Gibt Informationen ueber den Test aus */
public abstract void infoBenchmark();
/* Methoden fuer Appletdarstellung */}
/** Einrichten des Start-Buttons und des Ausgabe-TextAreas
* und Informationen ueber den Test ausgeben.
*/
public void init() {
isApplet = true; // Ausgabe in Applet
this.setLayout(new BorderLayout(0, 0));
runButton = new Button("Benchmark starten");
this.add("North", runButton);
textArea = new TextArea(15, 60);
textArea.setFont(new Font("Helvetica", Font.PLAIN, 12));
textArea.setEditable(false);
this.add("Center", textArea);
this.show(); // alles anzeigen
infoBenchmark();
}
/** Bei Klick auf den Start-Button wird der Benchmark
* ausfuehren, andere Events werden in der Event-Kette
* weitergeben.
* Es gibt keine Abfrage ob ein Test bereits laeuft!
*/
public boolean action(Event e, Object o) {
if (e.target == runButton) {
runBenchmark();
return true;
}
return super.action(e, o);
}
}
MatrixBenchmark
/** SMall JVM-Benchmark-Collection: Matrizenrechnung
* @version 1.1
* @author Marc Schanne <Marc.Schanne@stud.uni-karlsruhe.de>
*/
import java.util.*;
/** Matrizen(Zeilen x Spalten)-Klasse mit
* Multiplikation und Gauss-Elimination
*/
class Matrix {
public double elem[][]; // Matrix-Elemente
public int rows; // Anzahl der Zeilen und
public int cols; // Spalten
/** Erzeugen der Matrix(rows x cols) */
public Matrix(int r, int c) {
rows = r;
cols = c;
elem = new double[rows][cols];
}
/** Konstruieren einer erweiterten Matrix fuer die Gauss-
* Elimination aus einer quadradtischen Matrix A und einem
* Vektor b.
*/
public Matrix(QMatrix a, VMatrix b) {
rows = a.rows;
cols = a.cols+1;
elem = new double[a.rows][a.cols+1];
int i, j;
/* Verwendung der schnellen System-Routine arraycopy().
* Vgl. dazu Abschnitt \ref{arraycopy}
*/
try {
for (i = 0; i < rows; i++)
System.arraycopy(a.elem[i], 0, elem[i], 0, a.cols);
}
catch(ArrayIndexOutOfBoundsException e) { }
catch(ArrayStoreException e) { }
for (i = 0; i < rows; i++)
elem[i][a.cols] = b.elem[i][0];
}
/** Matrix mit zufaelligen Double-Werten fuellen */
public final void randomFill() {
Random random = new Random();
int i, j;
for (i = 0; i < rows; i++)
for (j = 0; j < cols; j++)
elem[i][j] = random.nextDouble();
}
/** Einfache Matrizenmultiplikation in O(n\^3) */
public final Matrix mult(Matrix b) {
int i, j, k;
Matrix c = new Matrix(rows, b.cols);
for (i = 0; i < rows; i++) {
for (j = 0; j < b.cols; j++) {
for (k = 0; k < cols; k++) {
c.elem[i][j] += elem[i][k] * b.elem[k][j];
}
}
}
return c;
}
/** Vorwaerts-Elimination nach Gauss mit Pivot-Suche */
public final void eleminate() {
double[] elem_i, elem_max, elem_j; // Vgl. Abschnitt 3.3
double dummy;
int i, j, k, max;
for (i = 0; i < rows; i++) {
max = i;
for (j = i+1; j < rows; j++)
if (Math.abs(elem[j][i]) >
Math.abs(elem[max][i])) max = j;
elem_i = elem[i];
elem_max = elem[max];
for (k = i; k < cols; k++) {
dummy = elem_i[k];
elem_i[k] = elem_max[k];
elem_max[k] = dummy;
}
for (j = i+1; j < rows; j++) {
elem_j = elem[j];
for (k = cols-1; k >= i; k--)
elem_j[k] -= elem_i[k] * elem_j[i] / elem_i[i];
}
}
}
/** Rueckwaerts-Einsetzen (Gauss)
* Der Loesungsvektor wird erzeugt und zureckgegeben.
*/
public final VMatrix substitute() {
VMatrix x = new VMatrix(rows);
double dummy;
int i, k;
for (i = rows-1; i >= 0; i--) {
dummy = 0.0;
for (k = i+1; k < cols-1; k++)
dummy += elem[i][k] * x.elem[k][0];
x.elem[i][0] = (elem[i][cols-1]-dummy) / elem[i][i];
}
return x;
}
/** Ueberschreibt Object.toString */
public String toString() {
int i, j;
StringBuffer dummy = new StringBuffer("");
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++)
dummy.append(elem[i][j] + ", ");
dummy.append("\n");
}
String out = new String(dummy);
return out;
}
}
/** Klasse quadratischer Matrizen
* (direkte Kindklasse "normaler" Matrizen)
* Für quad. Matrizen kann der Gauss-Alg. aufgerufen werden.
*/
class QMatrix extends Matrix {
public QMatrix(int r) {
super(r, r);
}
/** Gauss, verwendet eleminate(), substitute() */
public final VMatrix gauss(VMatrix y) {
Matrix ay = new Matrix(this, y);
ay.eleminate();
VMatrix x = ay.substitute();
return x;
}
}
/** Vektoren sind ebenfalls als Kindklasse von Matrix
* implemntiert.
*/
class VMatrix extends Matrix {
public VMatrix(int r) {
super(r, 1);
}
}
/** Benchmark mit grossen Matrizen
* Multiplikation und Gauss (keine optimierten Alg.)
*/
public class MatrixBenchmark extends Benchmark {
public void runBenchmark() {
printBenchmark("Matrixmutliplikation in O(n\^3)");
QMatrix a = new QMatrix(200);
QMatrix b = new QMatrix(200);
a.randomFill(); b.randomFill();
Matrix c;
beginBenchmark(); // Test-Start
c = a.mult(b); // C = A * B
endBenchmark(); // Test-Ende
printBenchmark("Gauss-Elimination fuer LGS");
QMatrix m = new QMatrix(400);
VMatrix y = new VMatrix(400);
VMatrix x;
m.randomFill(); y.randomFill();
beginBenchmark(); // Test-Start
x = m.gauss(y); // A * x = y
endBenchmark(); // Test-Ende
}
public void infoBenchmark() {
printBenchmark("SMall JVM-Benchmark-Collection: "
+ "Matrizenrechnung");
printBenchmark("v1.1");
printBenchmark("Marc Schanne "
+ "<Marc.Schanne@stud.uni-karlsruhe.de>\n");
}
/** Application-Main
* Benchmark-Objekt erzeugen und Test ausfuehren
*/
public static void main(String args[]) {
MatrixBenchmark mb = new MatrixBenchmark();
mb.infoBenchmark();
mb.runBenchmark();
}
}
PolyBenchmark
/** SMall JVM-Benchmark-Collection: Polynome
* @version 1.1
* @author Marc Schanne <Marc.Schanne@stud.uni-karlsruhe.de>
*/
import java.util.*;
/** Polynom n-ter Ordung mit Multiplikation */
class Poly {
private double elem[]; // Koeffizentenfeld
/** double-Feld für Koeffizenten mit Laenge n erzeugen */
public Poly(int n) {
elem = new double[n];
}
/** Polynom der Laenge n erzeugen und die ersten Elemete aus
* Polynom a kopieren.
*/
private Poly(Poly a, int n) {
int i;
elem = new double[n];
// Vgl. Abschnitt \ref{arraycopy}
try {
System.arraycopy(a.elem, 0, elem, 0, a.elem.length);
}
catch(ArrayIndexOutOfBoundsException e) { }
catch(ArrayStoreException e) { }
for (i = a.elem.length; i < n; i++)
elem[i] = 0;
}
/** Zufaelliges Fuellen mit Werten */
public final void randomFill() {
int i, len;
Random random = new Random();
len = elem.length;
for (i = 0; i < len; i++)
elem[i] = random.nextDouble();
}
/** Rekursive Funktion zum Multipizieren der Polynome this
* und b.
* Beschr.: Nach dem Prinzip "Teile und Herrsche" wird
* das Problem der Multiplikation von Polynomen der
* Groesse n durch Loesen von 3 Teilproblemen der
* Groesse n/2 geloest.
* Fuer n=1 ist das Produkt gleich dem Skalar-
* produkt der beiden Konstanten-Koeffizienten.
* Aufwand: O(n\^lg3)
* Randbed: this.elem.length == b.elem.length == 2\^k
* (wird deshalb aus mult() aufgerufen)
*/
private final Poly multRec(Poly b) {
if (elem.length == 1) {
Poly c = new Poly(1);
c.elem[0] = elem[0] * b.elem[0];
return c;
}
else {
int len;
int len2 = elem.length / 2; // Zerlegung in 6 Polynome
Poly al = new Poly(len2); // der Laenge n/2:
Poly bl = new Poly(len2); // al, bl, ah, bh, t1, t2
try {
System.arraycopy(elem, 0, al.elem, 0, len2);
System.arraycopy(b.elem, 0, bl.elem, 0, len2);
}
catch(ArrayIndexOutOfBoundsException e) { }
catch(ArrayStoreException e) { }
Poly ah = new Poly(len2);
Poly bh = new Poly(len2);
try {
System.arraycopy(elem, len2, ah.elem, 0, len2);
System.arraycopy(b.elem, len2, bh.elem, 0, len2);
}
catch(ArrayIndexOutOfBoundsException e) { }
catch(ArrayStoreException e) { }
Poly t1 = new Poly(len2);
Poly t2 = new Poly(len2);
for (int i = 0; i < len2; i++) {
t1.elem[i] = al.elem[i] + ah.elem[i];
t2.elem[i] = bl.elem[i] + bh.elem[i];
}
Poly rm = new Poly(elem.length); // Teilberechnungen
rm = t1.multRec(t2);
Poly rl = new Poly(elem.length);
rl = al.multRec(bl);
Poly rh = new Poly(elem.length);
rh = ah.multRec(bh);
Poly c = new Poly(2*elem.length-1); // Rekombination
len = elem.length-1;
try {
System.arraycopy(rl.elem, 0, c.elem, 0, len);
System.arraycopy(rh.elem, 0, c.elem, len+1, len);
}
catch(ArrayIndexOutOfBoundsException e) { }
catch(ArrayStoreException e) { }
c.elem[len] = 0;
for (int i = 0; i < len; i++)
c.elem[len2+i] += rm.elem[i] - (rl.elem[i] + rh.elem[i]);
return c;
}
}
/** Mult hat 2 Aufgaben:
* 1) Aufruf des Multiplikations-Alg. (mutlRec()) mit
* Polynomen richtiger Groesse: n = 2\^(aufrunden(log_2(n))
* 2) Rueckgabe des Ergebnisses
*/
public final Poly mult(Poly b) {
Poly a2 = new Poly(this, (int)Math.pow(2, (double)((int)(
Math.log (Math.max(elem.length, b.elem.length)) /
Math.log(2.0)) + 1)));
Poly b2 = new Poly(b, (int)Math.pow(2, (double)((int)(
Math.log(Math.max(elem.length, b.elem.length)) /
Math.log(2.0)) + 1)));
return a2.multRec(b2);
}
/** Ueberschreibt Object.toString() */
public String toString() {
StringBuffer dummy = new StringBuffer("p(x) = ");
for (int i = elem.length-1; i > 0; i--)
if (elem[i] != 0.0)
dummy.append(elem[i] + "*x\^" + i + " + ");
dummy.append(elem[0]);
String out = new String(dummy);
return out;
}
}
/** Benchmark: Polynom-Multiplikation */
public class PolyBenchmark extends Benchmark {
/** der Test */
public void runBenchmark() {
printBenchmark("c(x) = a(x) * b(x); a, b vom Grad 4000");
Poly a = new Poly(4000);
Poly b = new Poly(4000);
Poly c;
a.randomFill(); b.randomFill();
beginBenchmark(); // Test-Start
c = a.mult(b); // c(x) = a(x) * b(x)
endBenchmark(); // Test-Ende
}
/** Versionsnummer und Name */
public void infoBenchmark() {
printBenchmark("SMall JVM-Benchmark-Collection: "
+ "Polynom-Multiplikation");
printBenchmark("v1.1");
printBenchmark("Marc Schanne "
+ "<Marc.Schanne@stud.uni-karlsruhe.de>\n");
}
/** Main-Prog. fuer Application
* Erzeugen des Benchmark-Objekts und Ausführen des Tests
*/
public static void main(String argv[]) {
PolyBenchmark pb = new PolyBenchmark();
pb.infoBenchmark();
pb.runBenchmark();
}
}
PrimeBenchmark
/** SMall JVM-Benchmark-Collection: Primzahlen
* @version 1.1
* @author Marc Schanne <Marc.Schanne@stud.uni-karlsruhe.de>
*/
import java.util.*;
/** PrimeList stellt eine Prime-Flag-Liste fuer die Zahlen
* von 2 bis len und eine Methode zur Primzahlenberechnung
* mit dem Sieb des Eratosthenes zur Verfuegung.
*/
class PrimeList {
private boolean flag[]; // Prime-Flag fuer 2 ...
private int sqrtLen; // ... bis sqrtLen\^2
/** @param sqrtLen Quadrat-Wurzel der gewuenschten
* Array-Laenge
*/
public PrimeList(int sqrtLen) {
this.sqrtLen = sqrtLen;
flag = new boolean[sqrtLen*sqrtLen+1];
int i, len;
len = flag.length; // Annahme: alle prim
for(i = 0; i < len; i++) flag[i] = true;
}
/** Primzahlenberechnug mit Sieb der Eratosthenes
* von 2 bis sqrtLen\^2
*
* Bsp. fuer sqrtLen=4:
* Init. 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
* i=2 2 3 - 5 - 7 - 9 - 11 - 13 - 15 -
* i=3 2 3 - 5 - 7 - - - 11 - 13 - - -
* i=4 keine Primzahl. Fertig.
*/
public final void runSieve() {
int i, k, prime;
for (i = 2; i <= sqrtLen; i++) {
if(flag[i]) {
prime = i;}
for (k = i + prime; k < flag.length; k += prime)
flag[k]=false;
}
}
}
/** zur einfachen Ausgabe, ueberschreibt Object.toString() */
public String toString() {
int i, len;
StringBuffer dummy = new StringBuffer("Primz. von 2 bis ");
dummy.append((flag.length-1) + ": ");
len = flag.length;
for (i = 2; i < len; i++)
if (flag[i])
dummy.append(i + " ");
String out = new String(dummy);
return out;
}
}
/** Benchmark mit Primzahlenwaesche des Eratosthenes */
public class PrimeBenchmark extends Benchmark {
/** Erzeugt ein PrimeList-Objekt und ruft das Primzahlensieb
* dafuer auf.
*/
public void runBenchmark() {
printBenchmark("1) Erzeugen des PrimeList-Objects (im "
+ "wesentlichen ein boolean-Array fuer die "
+ "Zahlen 2 bis 9.000.000)");
beginBenchmark(); // Test-Start
PrimeList pl = new PrimeList(3000); // Objekt erzeugen
endBenchmark(); //Test-Ende
printBenchmark("2) Primzahlenberechnung selbst");
beginBenchmark(); // Test-Start
pl.runSieve(); // Primzahlensieb
endBenchmark(); // Test-Ende
}
public void infoBenchmark() {
printBenchmark("SMall JVM-Benchmark-Collection: "
+ "Primezahlensieb");}
printBenchmark("v1.1");
printBenchmark("Marc Schanne"
+ "<Marc.Schanne@stud.uni-karlsruhe.de>\n");
};
/** Application-Main */
public static void main(String argv[]) {
PrimeBenchmark pb = new PrimeBenchmark();
pb.infoBenchmark();
pb.runBenchmark();
}
}
SortBenchmark
/** SMall JVM-Benchmark-Collection: Integerfeld sortieren
* @version 1.1
* @author Marc Schanne <Marc.Schanne@stud.uni-karlsruhe.de>
*/
import java.util.*;
/** Liste von Integern mit verschiedenen elementaren
* Sortier-Algorithmen (Bubble-Sort, Insertion-Sort und
* Shell-Sort)
*/
class SortList {
private int elem[];
/** int-Feld der Laenge len erzeugen */
public SortList(int len) {
elem = new int[len];
}
/** Liste mit Zufallsintegerzahlen fuellen */
public final void randomFill() {
int i, len;
Random random = new Random();
len = elem.length;
for (i = 0; i < len; i++)
elem[i] = random.nextInt();
}
/** Bubble-Sort (Sortieren durch Austauschen)
* Beschr.: Durchlaufe immer wieder das feld und vertausche
* jedesmal, wenn es notwendig ist, benachbarte
* Elemente (wenn bei einem Durchlauf kein
* Austausch mehr erforderlich ist, ist die Datei
* sortiert).
* Aufwand: quadratisch
*/
public final void sortBubbleSort() {
int i, j, dummy;
for (i = elem.length; i >= 0; i--)
for (j = 1; j <= i; j++)}
if (elem[j-1] > elem[j]) {
dummy = elem[j-1];
elem[j-1] = elem[j];
elem[j] = dummy;
}
}
/** Insertion-Sort (Sortieren durch Einfuegen)
* Beschr.: Betrachte die Elemnte eines nach dem anderen und
* fuege jedes an seinen richtigen Platz zwischen
* den bereits betrachteten ein. Das gerade
* betrachtete Element wird eingefuegt, indem die
* groessten Elemente einfach um eine Position nach
* rechts bewegt werden.
* Aufwand: quadratisch, aber fuer "fast sortierte" Felder
* linear
*/
public final void sortInsertionSort() {
int i, j, dummy, len;
len = elem.length;
for (i = 1; i < len; i++) {
dummy = elem[i];
j = i;
while ((j > 0) \&\& (elem[j-1] > dummy)) {
elem[j] = elem[j-1];
j = j - 1;
}
elem[j] = dummy;
}
}
/** Shell-Sort eine Verbesserung von Insertion-Sort
* Beschr.: Die Zahlenliste wird in mehreren Durchgaengen
* mit Insertion-Sort (vor-)sortiert. Dabei
* werden Teilfolgen (mit bestimmtem Offset)
* sortiert.
*/
public final void sortShellSort() {
int h = 1; // h-sortiert mit Folge
int i, j, dummy, len;
len = elem.length;
do {
h = 3 * h + 1; // ..,1093,364,121,40,13,4,1
} while (h < len);}
do { // Beginn Sortieralg.
h = h / 3;
for (i = h+1; i <= len; i++) {
dummy = elem[i-1];
j = i;
while (elem[j-h-1] > dummy) {
elem[j-1] = elem[j-h-1];
j = j - h;
if (j <= h) break;
}
elem[j-1] = dummy;
}
} while (h != 1);
}
/** Ueberschreibt Object.toString() */
public String toString() {
int i, len;
StringBuffer dummy = new StringBuffer(" ");
len = elem.length;
for (i = 0; i < len; i++)
dummy.append(elem[i] + " ");
String out = new String(dummy);
return out;
}
}
/** Haeufiges Sortieren eines Integer-Feldes mit Shell-Sort */
public class SortBenchmark extends Benchmark {
public void runBenchmark() {
printBenchmark("1000 mal Array der Groesse 1000 in einer "
+ "Methode mit Zufallszahlen fuellen und mit "
+ "einer 2. Methode sortieren");
SortList sl = new SortList(1000);
beginBenchmark(); // Test-Start
for (int i=0; i < 1000; i++) { // Schleife !!!
sl.randomFill(); // Fuellen mit Zufallszahlen
sl.sortShellSort(); // Sortieren
}
endBenchmark(); // Test-Ende
}
public void infoBenchmark() {
printBenchmark("SMall JVM-Benchmark-Collection: Sortieren "
+ "mit Shell-Sort");
printBenchmark("v1.1");
printBenchmark("Marc Schanne "
+ "<Marc.Schanne@stud.uni-karlsruhe.de>\n");
}
/** Main-Prog. fuer Application */
public static void main(String args[]) {
SortBenchmark sb = new SortBenchmark();
sb.infoBenchmark();
sb.runBenchmark();
}
}
InitBenchmark
/** SMall JVM-Benchmark-Collection: Objekte erzeugen
* @version 0.1
* @author Marc Schanne <Marc.Schanne@stud.uni-karlsruhe.de>
*/
import java.util.*;
/** Klasse mit Array-Objekt und einer Fuellmethode */
class Init {
private double elem[];
/** double-Feld mit Laenge n erzeugen */
public Init(int n) {
elem = new double[n];
}
/** Zufaelliges Fuellen mit Werten */
public final void randomFill() {
int i, len;
Random random = new Random();
len = elem.length;
for (i = 0; i < len; i++)
elem[i] = random.nextDouble();
}
}
/** Benchmark: Erzeugen von Objekten */
public class InitBenchmark extends Benchmark {
public void runBenchmark() {
int i, j;
Init a[] = new Init[1000];
printBenchmark("Init as init can");
beginBenchmark(); // Test-Start
for (j = 0; j < 100; j++) // 100 x
for (i = 0; i < 1000; i++) // 1000 Objekte
a[i] = new Init(1000); // (= Arrays) erzeugen
endBenchmark(); // Test-Ende
}
public void infoBenchmark() {
printBenchmark("SMall JVM-Benchmark-Collection: "
+ "Objekte erzeugen");
printBenchmark("v0.1");
printBenchmark("Marc Schanne "
+ "<Marc.Schanne@stud.uni-karlsruhe.de>\n");
}
/** Main-Prog. fuer Application */
public static void main(String argv[]) {
InitBenchmark ib = new InitBenchmark();
ib.infoBenchmark();
ib.runBenchmark();
}
}
RecBenchmark
/** SMall JVM-Benchmark-Collection: rekursiver Abstieg
* @version 0.1
* @author Marc Schanne <Marc.Schanne@stud.uni-karlsruhe.de>
*/
import java.util.*;
/** In einem grossen Array ermoeglicht diese Klasse einen
* rekursive Abstieg
*/
class Rec {
private double elem[];
/** double-Feld mit Laenge n erzeugen */
public Rec(int n) {
elem = new double[n];
}
/** Zufaelliges Fuellen mit Werten */
public final void randomFill() {
int i, len;
Random random = new Random();
len = elem.length;
for (i = 0; i < len; i++)
elem[i] = random.nextDouble();
}
/* rekursiver Aufruf von doRec */
public final double doRec(int l, int r) {
if (l == r) { // Abbruchbed.
return elem[l];
}
else {
return doRec(l, l+(int)((r-l)/2)) *
doRec(l+(int)((r-l)/2+1), r);
}
}
}
/** Benchmark: 1 Objekt erzeugen und darin einen rekursive
* Abstieg ausfuehren.
*/
public class RecBenchmark extends Benchmark {
public void runBenchmark() {
Rec a = new Rec(1000001);
a.randomFill();
beginBenchmark(); // Test-Start
double d = a.doRec(0, 1000000); // Rekursion aufrufen
endBenchmark(); // Test-Ende
}
public void infoBenchmark() {
printBenchmark("SMall JVM-Benchmark-Collection: "
+ "rekursiver Abstieg");
printBenchmark("v0.1");
printBenchmark("Marc Schanne "
+ <Marc.Schanne@stud.uni-karlsruhe.de>\n");
}
/** Main-Prog. fuer Application */
public static void main(String argv[]) {
RecBenchmark pb = new RecBenchmark();
pb.infoBenchmark();
pb.runBenchmark();
}
}
----------------------------------------------------------------
[home] [TOC] [prev] [next] [guestbook] [contact] (c) SM