Newsgroup: it.comp.lang.c
Titolo: clock()

Come faccio a sapere quanto tempo ci mette un programma a eseguirsi?
Per far questo inserisco nel programma:
#include <time.h>
int main() {
 
    	clock();    // first call clock
 
	.
	.
	. varie istruzioni
	.
	printf("Tempo trascorso: %d ", clock());
	}
Ma l'output e' irriconoscibile, mi da' -73265123, un numero assurdo...
Grazie per ogni suggerimento!
Saluti,
Christian


#include     <time.h>
#include    <stdio.h>
int main()
{
 int n;
 time_t start, end;
 start = clock();
 n = 4;
 n = 45;
 end = clock();
 printf("tempo = %d", end - start);
 return 0;
}

Grazie per la risposta:
ho risolto (penso) cosi':
#include     <time.h>
#include    <stdio.h>
main()
{
float tempo;
tempo=clock();
....cut
printf("tempo impiegato in secondi = %f", (tempo - clock())/1000);
}
Che ne dici?
ciao
Christian

Grazie per la risposta:
ho risolto (penso) cosi':
#include     <time.h>
#include    <stdio.h>
main()
{
float tempo;
tempo=clock();
....cut
printf("tempo impiegato in secondi = %f", (clock() - tempo)/1000);


 ha scritto nel messaggio
news:3A53294B...@yahoo.com...

tempo dev'essere di tipo clock_t, quindi va bene la dichiarazione di Gori
    clock_t tempo;
poi per stampare il tempo fai cosě:
    printf("tempo impiegato in secondi = %f", (clock() - tempo)/CLK_TCK);
dove CLK_TCK č una costante definita in time.h che indica il numero di clock
al secondo del processore.
--
BlackDemon
"Per la maggior parte dei programmi di posta elettronica, vigeva finora la
regola secondo cui dalla semplice lettura dei messaggi non poteva derivare
alcun tipo di pericolo. La situazione č cambiata da quando Microsoft si č
messa a sviluppare programmi di posta elettronica." - Maurizio Lazzaretti,
PC World 01/2001

 al secondo del processore.
Ho provato a modificare secondo le tue indicazioni ma mi da' sempre
tempo trascorso = 0.000.
Come l'avevo fatto io funzionava. Non e' che il problema e' %f, non so
forse ci vuole un altro formato?
Grazie e ciao
Christian

forse ci vuole un altro formato?
A dire il vero e' gia' buona che il programma non si pianti...
considera questo codice:
   int a=3;
   int b=2;
   double f=a/b;
f assume il valore 1.0 e non 1.5 poiche' la divisione viene fatta
fra variabili intere in intero e solo dopo viene fatta la conversione.
Se scrivi:
     printf("%f\n",(clock()-tempo)/CLOCKS_PER_SEC);
addirittura stai passando un valore intero a printf dove questo
si aspetta un valore double (cosa da non fare!). Un sistema per
risolvere e' il seguente:
     printf("%f\n",(clock()-tempo)/(double)CLOCKS_PER_SEC);
In questo modo la divisione e' fra un intero e un double e le
regole di promozione provvedono a richiedere la conversione
dell'intero in double prima del calcolo della divisione (e
anche printf e' piu' contenta ricevendo il double che le e'
stato promesso dalla stringa di formato :) ).
HTH
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 Ma l'output e' irriconoscibile, mi da' -73265123, un numero assurdo...
Eccoti un esempio funzionante (ma non penso che in questo modo si
raggiunga una buona precisione):
#include <stdio.h>
#include <time.h>
int main()
{
    long start;
    const long n = 1000000000;
    long i;
    start = clock();
    for ( i = 0; i < n; ++i );
    printf( "Elapsed time: %.2f sec\n", ( double )( clock() - start ) /
CLOCKS_PER_SEC );
    return 0;
}
EMG

 considera questo codice:
Strano perchè io dichiarando fine e inizio come clock_t se scrivo nel
codice:
    printf("%.3f", (fine - inizio) / CLK_TCK);
ottengo una precisione fino alla 3a cifra decimale. Ma Usare CLOCKS_PER_SEC
è meglio rispetto a CLK_TCK?
--
BlackDemon
"Per la maggior parte dei programmi di posta elettronica, vigeva finora la
regola secondo cui dalla semplice lettura dei messaggi non poteva derivare
alcun tipo di pericolo. La situazione è cambiata da quando Microsoft si è



Il valore ritornato da clock() va diviso per la macro CLK_TCK per ottenere
il tempo trscorso in secondi.
La chiamata va messa prima di printf(......)
HTH gfb

    double f=a/b;
Sono d'accordissimo, ma allora non ho capito una cosa: ti che tipo sono
le variabili clock()?
int? float? double? Sul Kernighan (p.341-342) non e' specificato.
Se ho capito male e clock() mi restituisce un int allora per dividerlo
per 1000 lo dovro' "castare" in un float.
Ciao
Christian

Ma Usare CLOCKS_PER_SEC è meglio rispetto a CLK_TCK?
Sulla documentazione ho trovato che e' preferibile utilizzare
CLOCKS_PER_SEC rispetto a CLK_TCK anche se hanno lo stesso valore
(Letteralmente MSDN cita: "The time in seconds is the value
returned by the clock function, divided by CLOCKS_PER_SEC.
CLK_TCK is equivalent, but considered obsolete." ).
Sicuramente e' un nome piu' parlante... credo che sia anche piu'
recente: CLK_TCK e' stato probabilmente il primo nome assegnato
a tale costante e ora e' presente per non perdere la compatibilita'
con il passato.


per 1000 lo dovro' "castare" in un float.
Facendo un cast di CLOCKS_PER_SEC oppure memorizzando il valore
restituito da clock() in variabili double il risultato e' prevedibile
e sara' di tipo double indipendentemente da cosa e' clock_t.
In questo caso mi sembra che costi poco scrivere codice portabile
anche sulle piattaforme in cui clock_t non e' intero.


    for ( i = 0; i < n; ++i );
Un compilatore serio dovrebbe tradurre questa riga in
     i=n;
(e molti lo fanno)


 (e molti lo fanno)
Però né BCC55 né DJGPP lo fanno.
EMG

 vale in generale pero'.
CLK_TCK vale 13107. è possibile risalire alla velocità (in Mhz) della CPU
partendo da CLK_TCK o CLOCKS_PER_SECOND?


 Allota sulla tua piattaforma clock_t e' double o float, oppure
No! clock_t e' generalmente di tipo intero (long su BCC) mai decimale.
Il trucco e' molto semplice CLK_TCK vale per i PC 18.2 cioe' e' una costante
float!!!
Quando esegui "(fine - inizio) / CLK_TCK" il risultato e' automatimanete un
float perche' hai usato una costante float nell'espressione.
ciao
donCiccio

Però né BCC55 né DJGPP lo fanno.
Io ho scritto la risposta perche' ricordo che in passato
mi sono scottato proprio su questa cosa... Nel codice
cercavo di cronometrare il tempo richiesto da una
somma e facevo qualcosa come:
  float a=1,b=2,c;
  int i;
  clock_t t,t1,t2;
  t=clock(); while ((t1=clock())==t);
  for (i=0; i<1000000; i++)
    c=a+b;
  t1=clock()-t1;
  t=clock(); while ((t2=clock())==t);
  for (i=0; i<1000000; i++)
    ;
  t2=clock()-t2;
e sia t1 che t2 erano nulli problema e' che il compilatore
spostava c=a+b fuori dal loop e poi il loop a vuoto spariva.
Penso che si trattasse del compilatore watcom C 9.x ma non
ricordo di preciso...
Facendo le prove con BCC55 ho effettivamente visto che
il loop non viene ottimizzato (non conosco pero' bene le
ottimizzazioni possibili con BCC55 in quanto Borland ha
rimosso la documentazione di dettaglio sugli switch di
compilazione nella versione disponibile free).
Con il Watcom C++ invece il loop viene in qualche modo
velocizzato in quanto il programma si mette a contare di 13
in 13 e anche g++ agisce in modo analogo contando pero' di
25 in 25 se si usa l'opzione di ottimizzazione di loop
unrolling (-funroll-loops). Immagino che lo stesso accada
con djgpp.
Con le variabili 'volatile' invece il compilatore e'
obbligato ad effettuare tutte le scritture richieste e
nell'ordine richiesto dal programma.
HTH


Il compilatore C ha due formati per la data interna, e di conseguenza
per l'orologio.
Il primo e' in forma numerica (il numero incomprensibile che leggi in
uscita dal tuo programma) e rappresenta il numero di clock dal momento
dell'accensione. Il tipo e' "time_t" che e' definito come long, e per
trasformarlo in un valore temporale comprensibile ci sono alcune
funzioni di libreria standar.
Il secondo formato e' letterale esteso.
Da questo esempio, volutamente lento, dovresti capire un po' tutto:
#include <time.h>
#include <stdio.h>
#define RUNS 1000
#define SIZE 10000
int mark[SIZE];
void main (void)
{
 time_t start,finish;
 int i,loop,n,num;
 time(&start);
 printf("\nInizio: %s",ctime(&start));
 /* Questo ciclo cerca i primi numeri tra 2 e SIZE */
 for (loop=0; loop<RUNS;++loop) {
  for (n=0; n<SIZE;n++) {
   /* Questo ciclo marca con -1 i numeri composti */
   for (num=0,n=2;n<SIZE;n++) {
    if (!mark[n]) {
     for (i=2*n;i<SIZE;i+=n) {
      mark[i] = -1;
     }
    }
    num++;
   }
  }
 }
 time(&finish);
 printf("\nFine  : %s",ctime(&finish));
 printf("\nTempo impiegato:%f secondi",difftime(finish,start));
}