Newsgroup: it.comp.lang.c++
Titolo: calcolare il tempo trascorso

come calcolare con una buona esattezza il tempo impiegato per fare dei
calcoli?
ho come l'impressione di aver già posto la stessa domanda qualche tempo fa
ma non mi sembra di aver ricevuto una risposta definitiva.
cioè io alla fine uso due metodi, che sono pressapoco uguali come risultati
ma entrambi
insoddifacenti , in pratica 1) clock()  2) _ftime
Ci sono metodi più accurati?
Ho fatto diverse prove ed ho notato un'infinità di problemi  :-(
- i risultati dovrebbero essere precisi al millisecondo mentre invece sono
sempre approx ai centesimi
- eseguendo i calcoli con la versione di release esce fuori un bel 0.000 per
tutti quanti, per quanti cicli gli faccia fare
- i tempi dei due metodi sono leggermente diversi
- eseguendo lo stesso metodo (in versione debug) 4-5 volte escono
 risultati sempre diversi, con una variazione inaccettabile se il tempo
è minore di 1 secondo!
qualcuno sa spiegarmi perchè?
------------------- codice di esempio ------------------
#include <time.h>
#include <stdio.h>
#include <sys/timeb.h>
1)
 long i, z, n;
 clock_t start,finish;
 double result;
 n = 1000000000;
 z = 0;
 printf(" Esecuzione di %ld di somme di interi ... \n", n);
 start = clock();
 for (i=0; i<n; i++) {
  z = z+1;
 }
 finish = clock();
 result = (double)(finish-start);
 printf(" Tempo trascorso in secondi: %2.9f\n\n ", result/CLOCKS_PER_SEC);
2)
   struct _timeb timebuffer;
   char *timeline;
   _ftime( &timebuffer );
   timeline = ctime( & ( timebuffer.time ) );
   printf( "The time is %.19s.%hu %s",
    timeline, timebuffer.millitm, &timeline[20] );
   long z = 0;
   for (long i=0; i<10000000; i++)
      z= z+1;
   _ftime( &timebuffer );
   timeline = ctime( & ( timebuffer.time ) );
   printf( "The time is %.19s.%hu %s",
    timeline, timebuffer.millitm, &timeline[20]);
-----------------------------------------------------
ciao e grazie

qualcuno sa spiegarmi perchè?
Penso di averlo fatto...
Luc.

  printf(" Tempo trascorso in secondi: %2.9f\n\n ", result/CLOCKS_PER_SEC);
Misurare il tempo di esecuzione di questo codice non ha senso. E non ne vedo il
motivo. Soprattutto non ha senso misurare il tempo di esecuzione di quel codice
compilato in versione release. Semplicemente perche' in versione release quel
codice si trasforma in:
long i;
long z=0;
long n=1000000000;
clock_t start,finish;
double result;
printf(" Esecuzione di %ld di somme di interi ... \n", n);
start = clock();
i=1000000000;
z=1000000000;
finish = clock();
result = (double)(finish-start);
printf(" Tempo trascorso in secondi: %2.9f\n\n ", result/CLOCKS_PER_SEC);
e dubito molto che fra start e stop possa esserci qualche differenza (persino se
clock avesse una risoluzione di un millisecondo).
In versione non release avrai tempi piu' alti. Su una mia macchina ho avuto
tempi di circa 8.65 secondi. Con una variazione di piu' o meno un centesimo. Una
variazione cosi' piccola e' dovuta a variabilità intrinseche alla macchina ed e'
reale. Ovvero eseguendo il codice piu' volte il tempo di esecuzione varia
realmente di volta in volta.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

Grazie per le risposte, sei stato davvero chiaro.
Ora alcune risposte diciamo che le "intuivo", ad esempio
che nella versione di relase i tempi sono sempre 0, ecc.
Semmai l'unica cosa che non è chiara è che mi sono
espresso male, dato che non ho spiegato il motivo per cui
vorrei calcolare questi tempi.
Il fatto è che conosco molto poco il C++ e per niente l'assembler
quindi è ovvio che il mio metodo non ha nè capo nè coda...
Ovvero io vorrei, che so, sapere se è più veloce
x++ di x = x+1
oppure
x / y  invece di  x div y  o di una serie di sottrazioni
oppure
if  ((x) && (y)) invece di  if (x)
oppure anche una funzione più complessa
ecc ecc.
come ripeto per sapere queste cose il metodo di calcolare dei tempi
è davvero molto "rozzo" e sarebbe meglio imparare quello che fa
internamente il linguaggio... ma ogni tanto mi viene voglia di fare queste
prove!

 prove!
La regola e': fidati del compilatore (e dell'ottimizzatore). Non vale quasi mai
la pena di pensare a queste cose. Se proprio vuoi studiati un pochino di
assembly e poi usa un compilatore che genera assembly o usa un debugger per
ispezionare il codice in runtime.
