Newsgroup: it.comp.lang.pascal
Titolo: Guardatemi sto code per un benchmark semplice

Mi è venuta l'idea di fare un programma che vede quando suoi clicli
riesce a fare il computer in 1 minuto.
Per quanto riguarda il problema del minuto, ho messo un gettime
all'inizio e uno durante il ciclo. Poi c'è la var final, dove si
calcola quando dovrebbe finire il minuto. Se lo start (ricalcolato) è
uguale a final, allora il programma si dovrebbe fermare e dire quanti
clicli è riuscito a fare il computer...
ma... lo start non raggiunge mai il final, perchè arrivato a un certo
punto, riparte daccapo...
dov'è sbaglio?
eppoi ho supposto che gettime dasse 4 valori di cui il penultimo
rappresenta i secondi e l'ultimo i centesimi di secondo. E' giusto?
Mi piacerebbe che il programma funzionasse, anche perchè la mia idea
funziona di sicuro: durante il funzionamento del programma la CPU
lavora al massimo.
Ecco il code:
program digibenchmark;
 uses WinDos, WinCrt;
 var
   ore, minuti, secondi, centesimi, final, start : Word;
 var n:extended;
 function LeadingZero(w : Word) : String;
 var
   s : String;
 begin
   Str(w:0,s);
   if Length(s) = 1 then
     s := '0' + s;
   LeadingZero := s;
 end;
 begin
   GetTime(ore,minuti,secondi,centesimi);
   start:=(secondi*100)+centesimi+(minuti*600)+(ore*360000);
   final:=start+6000;
   n:=0;
   write('DigiBenchmark');
   repeat
   n:=n+1;
   GetTime(ore,minuti,secondi,centesimi);
   start:=(secondi*100)+centesimi+(minuti*600)+(ore*360000);
   gotoxy(1,2);
   write(n);
   gotoxy(1,3);
   write('start',start);
   gotoxy(1,4);
   write('final',final);
   until (start=final);
   writeln('Il numero di cicli del programma eseguiti in 1 minuto
è',n);
end.

Perche non usi il contacicli della cpu?
Bye,
Raktzo

    ore, minuti, secondi, centesimi, final, start : Word;
il problema e' qua:  se definisci start e final come Word, il loro range 
sara' limitato a 0..65535 (16bit, senza segno). Quando la tua somma supera 
questo valore, riparte da zero.
Per risolvere puoi o definirle longint o altro (quarda i diversi formati 
numerici nella guida del tuo compilatore) oppure evitare di sommare le ore 
ad esempio :)  [non so' se questo e' sufficiente, potresti andare in 
overflow comunque]
Un altro metodo e' scrivere il benchmark diversamente: invece di calcolare 
quanti cicli fa' in un minuti, calcoli quanto tempo ci mette a fare N 
cicli, e poi inverti :)
-- 
Dreadnaut - 
http://dreadnaut.servebeer.com/
(Life would be easier if I had the source code)

 Perche non usi il contacicli della cpu?
perche' cerchi il problema e non rispondi alla domanda ? :)


> perche' cerchi il problema e non rispondi alla domanda ? :)
Perchè se ho una soluzione (IMHO) migliore la consiglio :-)
A parte gli scherzi, trovo diverse "controindicazioni".
Se il progetto è semplicemente didattico, ok, possiamo "divertirci" con
poco.
l'uso dell'extended che contiene solo interi la trovo "fuori dominio". Forse
pero sta usando il vecchio TP7(a cui manca gli int64), in questo caso
potrebbe essere accettato, ma valuterei anche l'uso dei LongInt.
Poi c'è l'uso delle word per start e final, le manda subito fuori range.
Se usa un SO multitasking (penso stia lavorando con il dos), dovrebbe anche
stoppare lo scheduler.
Per il motivo sopra, consiglio l'TSC e l'uso di tempi molto brevi per il
conteggio.
Bye,
Raktzo

Non usare Word ma usa Longint
Bye,
David

 il conteggio.
speriamo stia lavorando in dos. Il problema e' benchmark cosi' fatto in 
se' non ha molto senso: un ciclo fisso puo' essere ottimizzato in strani 
modi dal compilatore E dal processore in real time, e il conteggio 
difficilmente dara' una valutazione precisa delle capacita' della 
macchina. A riguardo gli consiglierei di leggersi qualcosa sui BogoMIPS 
:)
 - 
http://en.wikipedia.org/wiki/BogoMips
 - 
http://www.clifton.nl/index.html?bogomips.html


Raktzo
Riscrivi il code?

> Riscrivi il code?
Per quale pascal?
Ti spiego, il TSC è un INT64 e non è gestibile da TP7, cosa che invece
delphi o freepascal gestiscono.
Comunque, un metacode potrebbe essere
I:=ReadTSC;
sleep(1);
I:=ReadTSC-I;
considerato I come Int64, altrimenti dovresti leggere due LongInt e farti la
differenza.
e in questo modo hai i cicli CPU in 1 millisec, poi li rapporti al minuto.
Se lavori con Win, dovresti assegnare a quelle tre righe la priorita più
alta possibile (se non ricordo male la RealTime...) mentre con linux
dovresti fare il renice.
Bye,
Raktzo

>CUT
Allora: avete sbagliato le mie pretese. ho 16 anni e l'anno scorso la
mia professoressa di matematica di una 40ina d'anni ha tentato di
insegnarmi il "PASHCAL", la stessa che diceva che il clock della CPU
(deducendo questo dalla traduzione del libro "orologio") era quella
cosa che faceva memorizzare l'ora di quando salviamo i documenti Word.
Però io mi son letto un pò il libro di _matematica_ e cerco di
sfruttare al massimo le poche cose che ho interiorizzato di pascal...
e sono rimasto contento di aver fatto questo benchmark.
(Xò il portatile centrino 1.5 di mio fratello arriva a 277 con sto
programma, il mio l'ho messo come campione a 100).
Il compilatore è Turbo Pascal per Windows 1.5, con i longint non
riesco a far funzionare niente (type mismatch), però magari lo vorrei
ricompilare con Freepascal per i 32bit, e col vecchio turbopascal 7
per vedere come funge in dos (division by zero).
Questo è il mio risultato che funge:
il valore viene sempre uguale perchè l'approssimazione benchmark:3:0 è
parecchia. Ho usato word perchè ho trovato nell'esempio dell'Help del
Turbo pascal di "Gettime".
---------------------------------------------
program digibenchmark;
 uses WinDos, WinCrt;
 var
   ore, minuti, secondi, centesimi, final, start, f: Word;
 var n,benchmark:extended;
 function LeadingZero(w : Word) : String;
 var
   s : String;
 begin
   Str(w:0,s);
   if Length(s) = 1 then
     s := '0' + s;
   LeadingZero := s;
 end;
 begin
   GetTime(ore,minuti,secondi,centesimi);
   start:=secondi+(minuti*60)+(ore*3600);
   final:=start+60;
   n:=0;
   write('DigiBenchmark');
   repeat
   n:=n+1;
   GetTime(ore,minuti,secondi,centesimi);
   start:=secondi+(minuti*60)+(ore*3600);
   f:=final-start;
   gotoxy(1,2);
   writeln('Tempo residuo alla fine del test: ',f,' secondi');
   write(n:10:0,' cicli eseguiti fin''ora');
   until (start=final);
   clrscr;
   benchmark:=n/346105*100;
   writeln('Il numero di cicli del programma eseguiti in 1 minuto
è',n:10:0);
   writeln;
   writeln('Il valore di benchmark, prendendo un Pentium 4 2,66 Ghz e
SRAM di 512 Mb');
   writeln('su Windows XP ottimizzato come campione col valore 100
è');
   writeln(benchmark:3:0);
end.
--------------------------------------------
Me lo correggete? Eppoi nel ciclio vorrei pure far salvare un file
sull'HD con il numero N, in modo da "testare anche l'HD" (ehm..).

 sull'HD con il numero N, in modo da "testare anche l'HD" (ehm..).
Assign(), Reset() o Rewrite() o Append(), write() e/o writeln(), readblock,
writeblock()
Bye,
Raktzo

writeblock()
E' bello vedere che appena dico che ho 16 anni nessuno se ne frega
più.
Cmq: assign richiede una variabile di tipo testo, vero? Io non ho una
variabile di tipo testo. Devo trafugare prima N in una variabile di
tipo testo?

 tipo testo?
guarda ad esempio: 
http://utenti.lycos.it/turbop/Lezioni/6-3.htm


guarda ad esempio: 
http://utenti.lycos.it/turbop/Lezioni/6-3.htm
ne ho visti di esempi. Comunque non ci piace la variabile extended. E
non piace neanche a voi. Ok, la cambio, ma il longint non piace al
compilatore.
Errore: type mismatch dove sta benchmark:=n/346105*100;
program digibenchmark;
 uses WinDos, WinCrt;
 var
   ore, minuti, secondi, centesimi, final, start, f: Word;
 var n,benchmark:longint;
 function LeadingZero(w : Word) : String;
 var
   s : String;
 begin
   Str(w:0,s);
   if Length(s) = 1 then
     s := '0' + s;
   LeadingZero := s;
 end;
 begin
   GetTime(ore,minuti,secondi,centesimi);
   start:=secondi+(minuti*60)+(ore*3600);
   final:=start+60;
   n:=0;
   write('DigiBenchmark');
   repeat
   n:=n+1;
   GetTime(ore,minuti,secondi,centesimi);
   start:=secondi+(minuti*60)+(ore*3600);
   f:=final-start;
   gotoxy(1,2);
   writeln('Tempo residuo alla fine del test: ',f,' secondi');
   write(n,' cicli eseguiti fin''ora');
   until (start=final);
   clrscr;
   benchmark:=n/346105*100;
   writeln('Il numero di cicli del programma eseguiti in 1 minuto
č',n:10:0);
   writeln;
   writeln('Il valore di benchmark, prendendo un Pentium 4 2,66 Ghz e
SRAM di 512 Mb');
   writeln('su Windows XP ottimizzato come campione col valore 100
č');
   writeln(benchmark);
end.

 Errore: type mismatch dove sta benchmark:=n/346105*100;
perche' e' longINT(eger) e tu ci stai mettendo dentro un numero 
frazionario :)
puoi usare la funzione trunc() che elimina la parte decimale del numero


 
Io userei Round più che Trunc....
{ si si sono ancora vivo :P }
-- 
Il Razziatore,
The Only Good Windows is an uninstalled Windows
-----------------------------------------------
MSN   : 
IlRazz...@netscape.net
ICQ   : 67552596
Yhaoo : Razziatore82
-----------------------------------------------
Founder of MediaPlayer Project
http://mpp.iwebland.com

Non si ferma mai... i secondi ricominciano da 70  :-(
program digibenchmark;
 uses WinDos, WinCrt;
 var
   ore, minuti, secondi, centesimi, benchmark:word;
 var final, start, f, n: longint;
 function LeadingZero(w : Word) : String;
 var
   s : String;
 begin
   Str(w:0,s);
   if Length(s) = 1 then
     s := '0' + s;
   LeadingZero := s;
 end;
 begin
   GetTime(ore,minuti,secondi,centesimi);
   start:=(secondi*100)+centesimi+(minuti*600)+(ore*360000);
   final:=start+6000;
   n:=0;
   write('DigiBenchmark');
   repeat
   n:=n+1;
   GetTime(ore,minuti,secondi,centesimi);
   start:=(secondi*100)+centesimi+(minuti*600)+(ore*360000);
   f:=round((final-start)/100);
   gotoxy(1,2);
   writeln('Tempo residuo alla fine del test: ',f,' secondi');
   write(n,' cicli eseguiti fin''ora');
   until (start=final);
   clrscr;
   benchmark:=round(n/346105*100);
   writeln('Il numero di cicli del programma eseguiti in 1 minuto č
',n);


    until (start=final);
Io non mi fiderei troppo del =, se perdi il centesimo di secondo 
succede, appunto che devi aspetare 24 ore, o un anno, o... insomma 
mettere >= è caldamente consigliato :D


Questo č il meglio che ho pensato:
program digibenchmark;
 uses WinDos, WinCrt;
 var
   ore, minuti, secondi, centesimi, benchmark:word;
 var final, start, f: extended;
 var n:longint;
 begin
   GetTime(ore,minuti,secondi,centesimi);
   start:=(centesimi/100)+secondi+(minuti*60)+(ore*3600);
   final:=start+60;
   n:=0;
   write('DigiBenchmark');
   repeat
   n:=n+1;
   GetTime(ore,minuti,secondi,centesimi);
   start:=(centesimi/100)+secondi+(minuti*60)+(ore*3600);
   f:=final-start;
   gotoxy(1,2);
   writeln('Tempo residuo alla fine del test: ',f:2:0,' secondi');
   write(n,' cicli eseguiti fin''ora');
   until (f<=0);
   clrscr;
   benchmark:=round(n/346105*100);
   writeln('Il numero di cicli del programma eseguiti in 1 minuto č
',n);
   writeln;
   writeln('Il valore di benchmark, prendendo un Pentium 4 2,66 Ghz e
SRAM di 512 Mb');
   writeln('su Windows XP ottimizzato come campione col valore 100
č');
   writeln(benchmark);
end.
(devo rifare il campione)