DGL Benchmark - Versionsgeschichte

Flash: /* 2. Benchmark Output */

2010-01-09T22:10:48Z

‎2. Benchmark Output

Flash: /* Benchmark Prozess */

2009-12-27T13:46:49Z

‎Benchmark Prozess

Flash: /* getBenchmarkInfos-Methode */

2009-12-12T20:47:17Z

‎getBenchmarkInfos-Methode

Flash: /* 1.2. Programm-Kern */ Formatierung

2009-12-12T19:58:36Z

‎1.2. Programm-Kern: Formatierung

Flash: getBenchmarkInfos soll auch Canvas Dimension liefern

2009-12-12T19:56:38Z

getBenchmarkInfos soll auch Canvas Dimension liefern

Flash: /* 1.2. Programm-Kern */

2009-10-23T14:54:12Z

‎1.2. Programm-Kern

Flash: /* 1.1. Benchmark-Code */

2009-10-23T14:40:03Z

‎1.1. Benchmark-Code

Flash: /* 1.1. Benchmark-Code */ Mehrere SetUp Methoden + globale Validierungsmethode

2009-10-23T14:39:44Z

‎1.1. Benchmark-Code: Mehrere SetUp Methoden + globale Validierungsmethode

Flash: Spezifikation für den DGL_Benchmark

2009-10-17T22:13:19Z

Spezifikation für den DGL_Benchmark

Neue Seite

'''Vorwort'''
Diese Spezifikation beschreibt nur die für den Benchmark relevanten Teile.
Wie die grafische Ausgabe initialisiert wird ist den Programmierern überlassen.
Ebenso wie der Benchmark-Code eingebunden wird (neukompilieren des Programms oder
dynamisches Laden z.B. durch Java-Reflection) oder ob und wie eine GUI/Menü benötigt wird.

=Spezifikation - DGL Benchmark=
Dieses Dokument beschreibt die Fähigkeiten und den generellen Aufbau des Programms DGL Benchmark.
Das Programm erstellt Ausgaben in einer definierten Form, welche es ermöglichen Performancemessungen von
1. alternativen Implementierungen in der selben Umgebung
2. identische Implementierungen in verschiedenen Umgebungen
zu vergleichen.

==1. Aufbau des Programms==
Das Programm besteht aus einem Kern sowie dem Benchmark-Code.

===1.1. Benchmark-Code===

'''[Benchmark Klasse]'''
Jeder Benchmark wird durch genau eine Benchmark-Klasse abgebildet.
Der Benchmark Code befindet sich komplett in dieser Klasse.
Diese Benchmark Klasse wiederum befindet sich in einem eigenen Sourcecode-File (z.B. *.pas, *.java, *.cpp+*.h).

'''[Benchmark Zweck]'''
Jede Benchmark Klasse dient nur genau einem Benchmark-Zweck.
Beispiel: "Überprüfung der Performance der standard OpenGL Shading Methoden (Flat, Smooth)."
Für den Benchmark Zweck gibt es üblicherweise mindestends zwei alternative Implementationsvarianten.
Im Beispiel oben eine mit Flat-Shading und eine mit Smooth-Shading.

'''[Benchmark-Methode]'''

INPUT: keiner

OUTPUT: keiner

Jede Implementationsvariante des Benchmark-Zwecks wird in einer eigenen öffentlichen Methode der Benchmark Klasse
implementiert. Diese Methoden werden einheitlich mit dem präfix "benchmark_" benannt.
Es muss in jeder Benchmark-Klasse mindestens eine Benchmark-Methode vorhanden sein.

'''[Setup-Methode]'''

INPUT: Ein Boolean-Wert der angibt, ob die Setup-Methode zum ersten Mal aufgerufen wird (true) oder nicht (false).

OUTPUT: Ein leerer String ("") im Erfolgsfall oder aber eine Beschreibung wieso das Setup fehlschlug.

Die SetUp Methode ändert immer alle OpenGL Eigenschaften in die für den Benchmark benötigten Werte.

Beim ersten Aufruf der Setup-Methode muss diese prüfen ob die benötigte mindest-OpenGL-Version vorhanden ist bzw.
ob alle benötigten OpenGL Extensions, die der Benchmark benötigt, verfügbar sind.
Ist dies nicht der Fall liefert die Funktion eine Beschreibung des Problems (z.B. den Namen der fehlenden Extension) zurück.

Die SetUp Methode wird vor jedem Aufruf der Benchmark-Methode aufgerufen.

Die Setup-Methode wird einheitlich mit dem Namen "setupBenchmark" bezeichnet und ist öffentlich.

'''[getBenchmarkInfos-Methode]'''

INPUT: keiner

OUTPUT: Ein formatierter String mit Informationen über den Benchmark.
Der String enthält Zeilenumbrüche. Jede Zeile enthält genau einen Datensatz im Format "BEZEICHNER=WERT".
Folgende Bezeichner sind vorgesehen

;Name : Der Benchmarkname. Sollte eindeutig sein. <br/>z.B. durch das Vorranstellen des DGL-Usernamen (z.B. Flash.ShadingBenchmark)
;Autor : Der/Die Autor(en)
;Version : Version des Vorliegenden Benchmarks. <br/>(Die Version ist eine Ganzzahl beginnend bei 1 . Die Version eines Benchmarks wird immer dann um 1 erhöht, wenn eine Änderung am Code durchgeführt wurde die eine Performanceänderung einer der Benchmark-Methoden nach sich ziehen könnte.)
;Zweck : Der Benchmarkzweck
;Loops : Anzahl der Wiederholungen die zur Messung gemacht werden sollen. Dient als Parameter für das Benchmark-Programm. Ganzzahliger Wert. Ist dies nicht angegeben wird 50 als Standardwert genutzt. Wertebereich: 0 < Loops <= 1000.
Mindestens enthalten sein muss der Name des Benchmarks, sowie die Version.

Die Info-Methode wird einheitlich mit dem Namen "getBenchmarkInfos" bezeichnet und ist öffentlich.
Jede Benchmark-Klasse muss genau eine Info-Methode besitzen.

===1.2. Programm-Kern===
Der Programm-Kern steuert den Benchmark Ablauf, den Aufruf des Benchmark-Codes sowie
die Erstellung der Benchmark Ausgaben (siehe "2. Benchmark Output").

'''[Vorbereitung]'''
Das Benchmarkprogramm muss für jeden Benchmark derart vorbereitet werden, dass der Benchmark-Code, welcher nicht Teil des Kernes ist, in diesem verfügbar ist. Falls keine geeigneteren Möglichkeiten zur Verfügung stehen, kann dies dadurch geschehen, dass der Programmierer des Benchmark-Codes den Sourcecode des "DGL Benchmark" Programms nimmt und dort die Einbindung manuell durchführt, neu kompiliert und den Benchmark dann zur Verfügung stellt.

'''[Benchmark Prozess]'''
Der Benchmarkprozess:

1. Aufruf von "getBenchmarkInfos" der Benchmark-Klasse.

2. Auswerten der Rückgabe.
- Prüfen ob Name und Version enthalten ist. Falls nicht: Abbrechen und Ausgabe wie unter 2.2. beschrieben.
- Prüfen ob Loops angegeben wurde. Falls ja prüfen ob der Wert valide (sonst 50 verwenden).

3. Aufruf von "setupBenchmark(true)" der Benchmark-Klasse.

4. Auswerten der Rückgabe.
- Falls Rückgabe ungleich "" ist, dann Abbrechen und Ausgabe wie unter 2.3. beschrieben.

5. Für jede Implementationsveriante (Benchmark-Methode) wird eine Liste der Messungen erstellt.

6. START DES BENCHMARKS (Schleifenbeging (von 1 bis Loops))<br/>
6.1. "setupBenchmark(false)"<br/>
6.2. starten der Zeitmessung<br/>
6.3. Aufruf der Benchmark-Methode<br/>
6.4. stoppen der Zeitmessung<br/>
6.5. speichern des gemessenen Zeit in dafür erstellen Liste (siehe Schritt 5)

6.1.-6.5. für die anderen Benchmark-Methoden
ES WERDEN PRO SCHLEIFENDURCHLAUF IMMER ALLE BENCHMARK-FUNKTIONEN AUSGEFÜHRT.

Beispiel '''RICHTIG''': Loops = 5; 2 Benchmarkfunktionen; resultierende Reihenfolge: B1B2 B1B2 B1B2 B1B2 B1B2

Beispiel '''FALSCH ''': Loops = 5; 2 Benchmarkfunktionen; resultierende Reihenfolge: B1B1B1B1B1 B2B2B2B2B2

7. Berechnen der Werte für jede Benchmark-Methode mithilfe der gespeicherten Werte
Berechnet werden
* durchschnittliche Ausführungsdauer des Codes (<AVERAGE_TIME>)
* daraus resultierende theoretische Framezahl (<AVERAGE_FRAMES>)
* Standardabweichung (<STD_DEVIATION>)

8. Schreiben der Ausgabe wie unter 2.1.

'''[Zeitmessung]'''
Zwischen Beginn und Ende der Zeitmessung darf Nichts außer dem Aufruf der aktuell gemessenen Benchmark-Methode stehen.
Zur Zeitmessung wird die genaueste Verfügbare Technik eingesetzt.

==2. Benchmark Output==
Die Ausgabe des Benchmarks erfolgt im XML Format.
Ziel ist es die Daten in einem Zweiten Schritt in einer zentralen Datenbasis automatisch einzulesen um darüber
Auswertungen erstellen zu können.

===2.1. Ausgabe im Erfolgsfall===
<DGLBENCHMARK>
<HEADER>
<BENCHMARK_INFROMATION>{Die Ausgabe von getBenchmarkInfos}</BENCHMARK_INFROMATION>
<LANGUAGE>{Programmiersprache in der der Code geschrieben wurde}</LANGUAGE>
<LOOPS>{Anzahl Loops}</LOOPS>
</HEADER>
<DATA>
<IMPLEMENTATION name="{Benchmark-Methoden-Name}">
<AVERAGE_TIME>{Durchschnittliche Zeit}</AVERAGE_TIME>
<AVERAGE_FRAMES>{Aus der durschn. Zeit berechnete Theoretische Framezahl}</AVERAGE_FRAMES>
<STD_DEVIATION>{Standardabweichung der Werte}</STD_DEVIATION>
</IMPLEMENTATION>

<IMPLEMENTATION ...
</DATA>
</DGLBENCHMARK>

===2.2. Ausgabe wenn Benchmark-Klasse nicht den Vorgaben entspricht===
<DGLBENCHMARK>
<HEADER>
<BENCHMARK_INFROMATION>{Die Ausgabe von getBenchmarkInfos}</BENCHMARK_INFROMATION>
<LANGUAGE>{Programmiersprache in der der Code geschrieben wurde}</LANGUAGE>
<LOOPS>{Anzahl Loops}</LOOPS>
</HEADER>
<ERROR type="INVALID_BENCHMARK_STRUCTURE">
{Wenn möglich detailierte Beschreibung was falsch ist, sonst leer.}
</ERROR>
</DGLBENCHMARK>

===2.3. Ausgabe wenn Benchmark-Vorraussetzungen am aktuellen System nicht erfüllt sind===
<DGLBENCHMARK>
<HEADER>
<BENCHMARK_INFROMATION>{Die Ausgabe von getBenchmarkInfos}</BENCHMARK_INFROMATION>
<LANGUAGE>{Programmiersprache in der der Code geschrieben wurde}</LANGUAGE>
<LOOPS>{Anzahl Loops}</LOOPS>
</HEADER>
<ERROR type="BENCHMARK_REQUIREMENTS_NOT_MET">
{Wenn möglich detailierte Beschreibung was fehlt, sonst leer.}
</ERROR>
</DGLBENCHMARK>

@@ Zeile 112: / Zeile 112: @@
-. Aufruf von "validateBenchmark" der Benchmark-Klasse.<br>
+. Aufruf von "getBenchmarkInfos" der Benchmark-Klasse.<br>
-- Falls Rückgabe ungleich "" ist, dann Abbrechen und Ausgabe wie unter 2.3. beschrieben.
+- Prüfen ob Name und Version enthalten ist. Falls nicht: Abbrechen und Ausgabe wie unter 2.2. beschrieben.<br>
-. Aufruf von "getBenchmarkInfos" der Benchmark-Klasse.<br>
+. Aufruf von "validateBenchmark" der Benchmark-Klasse.<br>
-- Prüfen ob Name und Version enthalten ist. Falls nicht: Abbrechen und Ausgabe wie unter 2.2. beschrieben.<br>
+- Falls Rückgabe ungleich "" ist, dann Abbrechen und Ausgabe wie unter 2.3. beschrieben.
@@ Zeile 147: / Zeile 147: @@
 . Schreiben der Ausgabe wie unter 2.1.
 ====Zeitmessung====

@@ Zeile 21: / Zeile 21: @@
 ===1.1. Benchmark-Code===
-'''[Benchmark Klasse]'''
+====Benchmark Klasse====
 Jeder Benchmark wird durch genau eine Benchmark-Klasse abgebildet.
 Der Benchmark Code befindet sich komplett in dieser Klasse.
@@ Zeile 27: / Zeile 27: @@
-'''[Benchmark Zweck]'''
+====Benchmark Zweck====
 Jede Benchmark Klasse dient nur genau einem Benchmark-Zweck.
 ;Beispiel: ''"Überprüfung der Performance der standard OpenGL Shading Methoden (Flat, Smooth)."''
@@ Zeile 34: / Zeile 34: @@
-'''[Benchmark-Methode]'''
+====Benchmark-Methode====
 INPUT:	keiner
@@ Zeile 45: / Zeile 45: @@
-'''[Validate-Methode]'''
+====Validate-Methode====
 INPUT:	keiner
@@ Zeile 59: / Zeile 59: @@
-'''[Setup-Methoden]'''
+====Setup-Methoden====
 INPUT:	keiner
@@ Zeile 75: / Zeile 75: @@
-'''[getBenchmarkInfos-Methode]'''
+====getBenchmarkInfos-Methode====
 INPUT:	keiner
@@ Zeile 89: / Zeile 89: @@
 ;Loops	: Anzahl der Wiederholungen die zur Messung gemacht werden sollen. Dient als Parameter für das Benchmark-Programm. Ganzzahliger Wert. Ist dies nicht angegeben wird 50 als Standardwert genutzt. Wertebereich: 0 < Loops <= 1000.
 Mindestens enthalten sein muss der Name des Benchmarks, sowie die Version.
 Die Info-Methode wird einheitlich mit dem Namen "getBenchmarkInfos" bezeichnet und ist öffentlich.

@@ Zeile 160: / Zeile 160: @@
   <DGLBENCHMARK>
    <HEADER>
     <BENCHMARK_INFROMATION>{Die Ausgabe von getBenchmarkInfos}</BENCHMARK_INFROMATION>
     <LANGUAGE>{Programmiersprache in der der Code geschrieben wurde}</LANGUAGE>
@@ Zeile 178: / Zeile 179: @@
   <DGLBENCHMARK>
    <HEADER>
     <BENCHMARK_INFROMATION>{Die Ausgabe von getBenchmarkInfos}</BENCHMARK_INFROMATION>
     <LANGUAGE>{Programmiersprache in der der Code geschrieben wurde}</LANGUAGE>
@@ Zeile 190: / Zeile 192: @@
   <DGLBENCHMARK>
    <HEADER>
     <BENCHMARK_INFROMATION>{Die Ausgabe von getBenchmarkInfos}</BENCHMARK_INFROMATION>
     <LANGUAGE>{Programmiersprache in der der Code geschrieben wurde}</LANGUAGE>

@@ Zeile 88: / Zeile 88: @@
 ;Zweck	: Der Benchmarkzweck
 ;Loops	: Anzahl der Wiederholungen die zur Messung gemacht werden sollen. Dient als Parameter für das Benchmark-Programm. Ganzzahliger Wert. Ist dies nicht angegeben wird 50 als Standardwert genutzt. Wertebereich: 0 < Loops <= 1000.
 ;CanvasSize : Größe des OpenGL-Canvases im Format [Breite]x[Hoehe] in Pixel. ''Beispiel: 400x300''
 Die Info-Methode wird einheitlich mit dem Namen "getBenchmarkInfos" bezeichnet und ist öffentlich.

@@ Zeile 98: / Zeile 98: @@
 die Erstellung der Benchmark Ausgaben (siehe "2. Benchmark Output").
-'''[Vorbereitung]'''
+====Vorbereitung====
 Das Benchmarkprogramm muss für jeden Benchmark derart vorbereitet werden, dass der Benchmark-Code, welcher nicht Teil des Kernes ist, in diesem verfügbar ist. Falls keine geeigneteren Möglichkeiten zur Verfügung stehen, kann dies dadurch geschehen, dass der Programmierer des Benchmark-Codes den Sourcecode des ''"DGL Benchmark" Programms'' nimmt und dort die Einbindung manuell durchführt, neu kompiliert und den Benchmark dann zur Verfügung stellt.
-'''[Benchmark Prozess]'''
+====Benchmark Prozess====
 Der Benchmarkprozess:
@@ Zeile 147: / Zeile 147: @@
-'''[Zeitmessung]'''
+====Zeitmessung====
 Zwischen Beginn und Ende der Zeitmessung darf Nichts außer dem Aufruf der aktuell gemessenen Benchmark-Methode stehen.
 Zur Zeitmessung wird die genaueste Verfügbare Technik eingesetzt.

@@ Zeile 98: / Zeile 98: @@
 '''[Vorbereitung]'''
-Das Benchmarkprogramm muss für jeden Benchmark derart vorbereitet werden, dass der Benchmark-Code, welcher nicht Teil des Kernes ist, in diesem verfügbar ist. Falls keine geeigneteren Möglichkeiten zur Verfügung stehen, kann dies dadurch geschehen, dass der Programmierer des Benchmark-Codes den Sourcecode des "DGL Benchmark" Programms nimmt und dort die Einbindung manuell durchführt, neu kompiliert und den Benchmark dann zur Verfügung stellt.
+Das Benchmarkprogramm muss für jeden Benchmark derart vorbereitet werden, dass der Benchmark-Code, welcher nicht Teil des Kernes ist, in diesem verfügbar ist. Falls keine geeigneteren Möglichkeiten zur Verfügung stehen, kann dies dadurch geschehen, dass der Programmierer des Benchmark-Codes den Sourcecode des ''"DGL Benchmark" Programms'' nimmt und dort die Einbindung manuell durchführt, neu kompiliert und den Benchmark dann zur Verfügung stellt.
@@ Zeile 104: / Zeile 104: @@
 Der Benchmarkprozess:
-. Aufruf von "getBenchmarkInfos" der Benchmark-Klasse.
+. Validieren der Struktur der Benchmark-Klasse <br>
-. Auswerten der Rückgabe.
-- Prüfen ob Name und Version enthalten ist. Falls nicht: Abbrechen und Ausgabe wie unter 2.2. beschrieben.
+. Aufruf von "validateBenchmark" der Benchmark-Klasse.<br>
 - Prüfen ob Loops angegeben wurde. Falls ja prüfen ob der Wert valide (sonst 50 verwenden).
-. Auswerten der Rückgabe.
+. Für jede Implementationsveriante (Benchmark-Methode) wird eine Liste für die Messwerte erstellt.
-. Für jede Implementationsveriante (Benchmark-Methode) wird eine Liste der Messungen erstellt.
+. START DES BENCHMARKS (Schleifenbeging (von 1 bis Loops))<br/>
-. START DES BENCHMARKS (Schleifenbeging (von 1 bis Loops))<br/>
+.1.-5.5. für die anderen Benchmark-Methoden<br>
 ES WERDEN PRO SCHLEIFENDURCHLAUF IMMER ALLE BENCHMARK-FUNKTIONEN AUSGEFÜHRT.
@@ Zeile 131: / Zeile 134: @@
 Beispiel '''FALSCH ''': Loops = 5; 2 Benchmarkfunktionen; resultierende Reihenfolge: B1B1B1B1B1 B2B2B2B2B2
-. Berechnen der Werte für jede Benchmark-Methode mithilfe der gespeicherten Werte
 Berechnet werden
 * durchschnittliche Ausführungsdauer des Codes (<AVERAGE_TIME>)
@@ Zeile 137: / Zeile 142: @@
 * Standardabweichung (<STD_DEVIATION>)
-. Schreiben der Ausgabe wie unter 2.1.
@@ Zeile 143: / Zeile 149: @@
 Zwischen Beginn und Ende der Zeitmessung darf Nichts außer dem Aufruf der aktuell gemessenen Benchmark-Methode stehen.
 Zur Zeitmessung wird die genaueste Verfügbare Technik eingesetzt.
 ==2. Benchmark Output==

@@ Zeile 43: / Zeile 43: @@
 implementiert. Diese Methoden werden einheitlich mit dem präfix "benchmark_" benannt.
 Es muss in jeder Benchmark-Klasse mindestens eine Benchmark-Methode vorhanden sein.
 '''[Validate-Methode]'''

@@ Zeile 29: / Zeile 29: @@
 '''[Benchmark Zweck]'''
 Jede Benchmark Klasse dient nur genau einem Benchmark-Zweck.
-Beispiel: "Überprüfung der Performance der standard OpenGL Shading Methoden (Flat, Smooth)."
+;Beispiel: ''"Überprüfung der Performance der standard OpenGL Shading Methoden (Flat, Smooth)."''
 Für den Benchmark Zweck gibt es üblicherweise mindestends zwei alternative Implementationsvarianten.
 Im Beispiel oben eine mit Flat-Shading und eine mit Smooth-Shading.
@@ Zeile 44: / Zeile 44: @@
 Es muss in jeder Benchmark-Klasse mindestens eine Benchmark-Methode vorhanden sein.
-'''[Setup-Methode]'''
+INPUT:	keiner
-INPUT:	Ein Boolean-Wert der angibt, ob die Setup-Methode zum ersten Mal aufgerufen wird (true) oder nicht (false).
+Die Validate Methode prüft ob die benötigte mindest-OpenGL-Version vorhanden ist bzw. ob alle benötigten OpenGL Extensions, die der Benchmark benötigt, verfügbar sind.
-OUTPUT:	Ein leerer String ("") im Erfolgsfall oder aber eine Beschreibung wieso das Setup fehlschlug.
+Die Validate Methode ist öffentlich und wird mit "validateBenchmark" bezeichnet.
 Die SetUp Methode ändert immer alle OpenGL Eigenschaften in die für den Benchmark benötigten Werte.
-Beim ersten Aufruf der Setup-Methode muss diese prüfen ob die benötigte mindest-OpenGL-Version vorhanden ist bzw.
+Für jede Benchmark Methode muss eine SetUp Methode existieren. Wird kein SetUp benötigt, kann die Methode leer bleiben.
-Die SetUp Methode wird vor jedem Aufruf der Benchmark-Methode aufgerufen.
+Die entsprechende SetUp Methode wird vor jedem Aufruf der zugehörigen Benchmark-Methode aufgerufen.
-Die Setup-Methode wird einheitlich mit dem Namen "setupBenchmark" bezeichnet und ist öffentlich.
+Die Setup-Methode ist öffentlich und wird einheitlich mit dem Namen "setupBenchmark_BENCHMARKNAME" bezeichnet.
@@ Zeile 79: / Zeile 91: @@
 Die Info-Methode wird einheitlich mit dem Namen "getBenchmarkInfos" bezeichnet und ist öffentlich.
 Jede Benchmark-Klasse muss genau eine Info-Methode besitzen.
 ===1.2. Programm-Kern===