Es soll vergleichen, welche von zwei Funktionen in verschiedenen Umgebungen besser/schneller arbeitet.
Es ist nichts fĂĽr Newbies und sollte wie alle Benschmarkergebnisse mit Vorsicht genossen werden.
Das Programm kann aber eine nĂĽtzliche Hilfe beim Erstellen und Vergleichen von Programmteilen sein.
Das Teil ist als Vorschlag und nicht als ultimativ fertiges Programm zu sehen.. nur fĂĽr den Fall, das jemand
was auszusetzen hat. Ich gehe nur auf Diskussionen ein wenn derjenige auch am Programm arbeitet!
/*******************************************************/
/* Bfast Benchmark Tool V1.0 fĂĽr CC2 / Multithreading */
/* Das Tool soll eine Möglichkeit zur Abschätzung des */
/* des Laufzeitverhaltens von CC2 c2 Programmen geben */
/* Copyright by Rolf Diesing, rolf(at)diesing.net */
/* SourceCode, und rechtliche Aspekte siehe GNU/GPL */
/* !! Benötigt werden aktuelle Versionen von lcdext !! */
/* !!! die Benchmarkergebnisse sind nur Richtwerte !!! */
/*******************************************************/
/* Derzeit wird nur die Anzahl der bearbeiteten */
/* Threadscheifen gezählt und verglichen. Mit Timern */
/* wäre das natürlich viel besser zu lösen... */
/*******************************************************/
/* Funktionsprinzip: Stadium 1 */
/* Es wird die Laufzeit von je einem Thread berechnet */
/* Funktionsprinzip: Stadium 2 */
/* Es wird die Laufzeit von beiden Threads verglichen */
/* Funktionsprinzip: Stadium 3 */
/* Es wird die Laufzeit von beiden Threads verglichen */
/* es läuft dabei ein zeitfressender Thread mit */
/* gleicher Priorität wie die anderen beiden */
/* Weitere Szenarien sind denkbar. */
/*******************************************************/
/* Wer möchte, kann sich hier austoben... */
/*******************************************************/
//here we go...
/*******************************************************/
/* Variablen/Constantensatz fĂĽr Testfunktionen (static)*/
/*******************************************************/
long DT1; // counter Demothread 1
long DT2; // counter Demothread 2
long DTL; // counter Lastthread 3
int godemo; //Semaphore um den Threadstart zu handeln
long cnt; // Variable, die der Lastthread unendlich hochzählt
/*******************************************************/
/* Platz Eigene Variablen (static) */
/*******************************************************/
//-->
int var1; //fĂĽr demo1
long var2; //fĂĽr demo2
/*******************************************************/
thread demo1
{
wait godemo;
DT1=DT1 + 1;
/*******************************************************/
/* Start der eigenen Testfunktion 1 */
/*******************************************************/
//-->
var1=var1+1;
/*******************************************************/
/* Ende der eigenen Testfunktion 1 */
/*******************************************************/
}
thread demo2
{
wait godemo;
DT2=DT2 + 1;
/*******************************************************/
/* Start der eigenen Testfunktion 2 */
/*******************************************************/
//-->
var2=var2+1;
/*******************************************************/
/* Ende der eigenen Testfunktion 2 */
/*******************************************************/
}
thread demolast
{
/*******************************************************/
/* LastThread, bitte an eigene WĂĽnsche anpassen */
/*******************************************************/
cnt=cnt+1;
}
/*******************************************************/
thread main
{
int i; //schleifenzähler in main
DT1=0;
DT2=0;
DTL=0;
godemo=0;
lcdext.init();
/* Stadium 1 */
lcdext.print("Bfast V1.0 mono");
lcdext.line(2);
run demo1; // ersten Thread testen
godemo=-1;
sleep 1000;
godemo=0;
halt demo1;
lcdext.zahl(DT1); // Ausgabe erster Thread (leer ca. 3350/Sek)
// Je höher die Werte, um so besser
run demo2; // zweiten Thread testen
godemo=-1;
sleep 1000;
godemo=0;
halt demo2;
lcdext.zahl(DT2); // Ausgabe zweiter Thread (leer ca. 3350/Sek)
// Je höher die Werte, um so besser
// beep, kann wegfallen, ist nur damit ich meine Ergebnisse nicht verpenne!
plm.beep (12);
sleep 500;
plm.beep (-1);
// beep
sleep 10000;
/* Stadium 2 10 Sek. fĂĽr das erste AHA-Erlebnis */
DT1=0; // Vorbereitung
DT2=0;
lcdext.clear();
lcdext.print("Bfast V1.0 duo");
lcdext.line(2); // Und los gehts...
run demo1; // zweiten Thread testen
run demo2; // ersten Thread testen
godemo=-1;
sleep 1000;
godemo=0;
halt demo1;
halt demo2;
lcdext.zahl(DT1); // Ausgabe erster Thread (leer ca. 1950/Sek)
lcdext.zahl(DT2); // Ausgabe zweiter Thread (leer ca. 1950/Sek)
// Sind die Werte stark unterschiedlich, hat man schon mal Angaben
// über die Leistungsfähigkeit. Die F. mit höheren Werten ist
// schneller. Das bedeutet jedoch noch nicht, das sie auch besser ist.
// beep, kann wegfallen, ist nur damit ich meine Ergebnisse nicht verpenne!
plm.beep (12);
sleep 500;
plm.beep (-1);
// beep
sleep 10000;
/* Stadium 3 10 Sek. fĂĽr das zweite AHA-Erlebnis */
DT1=0; // Vorbereitung
DT2=0;
lcdext.clear();
lcdext.print("Bfast V1.0 multi");
lcdext.line(2); // Und los gehts...
run demo1; // zweiten Thread testen
run demo2; // ersten Thread testen
run demolast; // Lastthread starten
godemo=-1;
sleep 1000;
godemo=0;
halt demo1;
halt demo2;
halt demolast;
lcdext.zahl(DT1); // Ausgabe erster Thread (leer ca. 700/Sek)
lcdext.zahl(DT2); // Ausgabe zweiter Thread (leer ca. 700/Sek)
// Auch hier sollten die Werte möglichst hoch sein und
// Bei drei Threads ist die Summe aller Schleifen nur noch 2100
// Bei zwei Threads waren es fast 3900
// Bei einem Thread "nur" 3350, man verschenkt also Rechenleistung
// wenn man ein Programm nur in einen Thread schreibt...
// beep, kann wegfallen, ist nur damit ich meine Ergebnisse nicht verpenne!
plm.beep (12);
sleep 500;
plm.beep (-1);
// beep
quit 63;
}
Hallo Andrè, sorry wegen dem Listing aber es muste sein :-)
GruĂ? Rolf
Antwort schreiben
Antworten:
Re: Benchmark Tool für CC2 (von Rolf - 14.07.2003 12:58)Re: Benchmark Tool für CC2 (von Rolf - 20.07.2003 20:10)