Newsgroup: it.comp.programmare.win32
Titolo: tempo per eseguire un blocco di istruzioni

Io sto programmando in Visual C++, Vorrei sapere se esite un modo molto
preciso per calcolare il tempo necessario all' esecuzione di un blocco di
istruzioni?
Io per uso clock() in questo modo:
start=colck()
.
.
. Blocco istruzioni
.
.
end=clock()
printf("Tempo di Esecuzione %f \n",(double)(end-start)/CLOCKS_PER_SEC)
Ma quello che riscontro è che  risultatno sempre tempi differenti (di circa
6/7 decimi su 8 secondi di esecuzione)  per lo stesso blocco di Istruzioni..
Vorrei evitare questo per poter confrontare variazioni dei tempi di
esecuzioni al  variare di alcune istruzioni interne al blocco di istruzioni.
Ciao e Grazie

 esecuzioni al  variare di alcune istruzioni interne al blocco di istruzioni.
Prova ad eseguire il tuo codice con priorità 'real-time', altrimenti la CPU  
non ha in esecuzione solo il tuo programma...
Luc.

 Io per uso clock() in questo modo:
Non conosco Clock() ma in genere per queste operazioni utilizzo
GetTickCount().
--
- Carlo -
c.b...@libero.it

 non ha in esecuzione solo il tuo programma...
E comunque non eseguirà solo il tuo pezzo di codice se imposti la modalità
Real-time, anche perchè nessun windows è un RTOS


 Real-time, anche perchè nessun windows è un RTOS
Ovvio... non siamo più ai tempi del C64... 8)
Però sicuramente sarà più preciso...
Luc.

 Però sicuramente sarà più preciso...
Anche io credevo fosse così ma non ho trovato riscontro ... forse quelle
flag vengono considerate solo in situazioni critiche.


 [...]
Ho letto brevemente la documentazione di clock() ... penso sia
equivalente
a leggere il registro RDTSC ?
Ecco la funzioncella (sorry, in Delphi!) , valida solo su processori
Pentium e compatibili (sul mio Duron funzia!):
////////////////////////////////////////////////////////////////
Function RDTSC: Int64;
var
  tsc : record
         case byte of
          1: (Whole: int64);
          2: (Lo, Hi: LongInt);
         end;
Begin
  asm
{Pentium RDTSC - Read Time Stamp Counter - instruction}
   db $0F; db $31;
{$ifdef Cpu386}
 mov [tsc.Lo],eax // the low dword
 mov [tsc.Hi],edx // the high dword
{$else}
 db $66
// {mov [TimeStamp.Lo],eax - the low dword}
 mov word ptr tsc.Lo,AX   db $66
// {mov [TimeStamp.Hi],edx - the high dword}
 mov word ptr tsc.Hi,DX
{$endif}
  end;
  Result := tsc.Whole;
End;
////////////////////////////////////////////////////////////////
Nota : La funz. non l'ho scritta io, l'ho trovata sul web.
Spero sia d'aiuto.  Ciao, Davide DG.

 a leggere il registro RDTSC ?
Scusa ma RDTSC non è mica il registro "ad alta performance" incrementato ad
ogni ciclo di clock? Se clock() fa quello non fa altro che utilizzare
l'istruzione assembly relativa o, meglio ancora,
QueryPerformanceCounter()/QueryPerformanceFrequency() dell'API
Ciao :)


 QueryPerformanceCounter()/QueryPerformanceFrequency() dell'API
Non so se rdtsc sia il timer ad alta perf., ma non credo : i due sistemi
danno risultati differenti, anche se analoghi (lineari)
QueryPerformanceCounter mi sembra la soluzione migliore (supportata a
livello di sistema!)
Ciao!! Davide DG.

 blocco di istruzioni.
Allora se ti interessa fare dei confronti relativi del tipo "va piu` forte
cosi`", senza fare misure di tempo assolute, puoi anche usare l'istruzione
assembly RDTSC. Ogni volta che la chiami, nei registri EDX:EAX e`
memorizzato un numero che viene incrementato di uno per ogni ciclo di clock.
Cosi` hai la massima risoluzione possibile.
--
Bye! Lorenzo Lutti
http://antani.virtualave.net/

 assembly RDTSC. Ogni volta che la chiami ...
Dovrebbe essere possibile evitare l'assembly (RDTSC) passando per
QueryPerformanceCounter()/QueryPerformanceFrequency()


Allora esiste un modo rapido per sapere a quandte istruzioni assembler
corrisponde un blocco di istruzioni???

 corrisponde un blocco di istruzioni???
Uno stesso numero di istruzioni asm non necessariamente impiega lo
stesso tempo.
Alcune istruzioni ci mettono più tempo delle altre! Devi considerare il
n° di cicli!
Le funzioni proposte (RDTSC e QueryPerformanceCounter) vanno più che
bene.
Se devi (ma devi veramente ?) ottenere notizie molto più precise sul
codice generato,
allora ti consiglio di utilizzare un disassemblatore e analizzarti il
codice a mano (o usando
un profiler, ma non ne conosco per Winzozz...)
--
Ciao !  Davide DG.

Infatti era abituato al Profiler di abituato sotto dos che permetteva un'
analisi accurata delle prestazioni in termini di velocita.
Beh Pazienza e grazie per l'aiuto!