Newsgroup: it.comp.lang.c
Titolo: Chiarimento su misurazione tempi esecuzione

Se ho un codice tipo:
int main(){
int a, i;
a=12;
a=13
for(i=0; i<1000; i++){
        faccio un po' di cose
}
return 0;
}
e voglio misurare in tempo di esecuzione del for con la clock().
Faccio così:
int main(){
int a, i;
double totaltime;
clock_t curc, oldc ;
a=12;
a=13
oldc = clock();
for(i=0; i<1000; i++){
        faccio un po' di cose
}
curc=clock();
totaltime=(double)((curc-oldc)/CLOCKS_PER_SEC);
return 0;
}
Giusto? Dovrei avere il tempo in secondi;

 gli stessi valori, perche` il contatore va in overflow e riparte da zero.
Una possibile soluzione?
TNX


Fare dei for che durino meno di 72 minuti.  ;-)
A parte la facile battuta si potrebbe usare time() per mantenere anche 
un conteggio dei secondi trascorsi e se sei vicino a 72*60 secondi 
sommare il valore fisso (clock_t e` long).  Tieni presente pero` che 
time() misura il tempo assoluto, mentre clock() il tempo di processo di 
un programma.


 un programma.
ok, ma come diavolo funziona la time?
Inoltre mi è accaduta una cosa strana.
Ho scritto questo codice:
#include <stdio.h>
#include <time.h>
int main(){
  clock_t start, finish; /* clock_t e' il tipo >aritmetico<
                          * restituito da clock() */
  long units,k;
  long i,j,l,l2,l3,l4;
  k=0;
  start = clock();
  for(i=0; i<100000; i++)
     for(j=0; j<10000; j++)
        k=i;
  finish = clock();
  printf("\nk=%d\n",k);
  units = finish - start;
  printf("\n%d time units (%f seconds)\n", units+1,
((double)units/(double)CLOCKS_PER_SEC));
  printf("\nCLOCKS: %f",(double)CLOCKS_PER_SEC);
  return 0;
}
L'ho lanciato su una macchina Unix e sembrava andare poi dopo 2 o 3 lanci è
andato tutto a puttane, cioè anche se faccio 20 for innestati di 20000
iterazioni mi da sempre unità di cpu uguali a zero e poi il programma a
tempi di esecuzioni istantanei.
Uffa !!!!!!


 tempi di esecuzioni istantanei.
Mi sembra normale che i tempi siano nulli.
Il ciclo interno e` inutile: il compilatore sicuramente lo toglie
ottenendo
   for(i=0; i<100000; i++)
      k=i;
A questo punto, probabilmente si accorge che il valore di k
all'uscita dal ciclo puo` essere calcolato una volta per tutte
senza fare nessuna iterazione, quindi leva anche l'altro ciclo
e arriva ad un semplicissimo
   k=100000;
Ti credo che ci mette un tempo nullo. prova a compilare
togliendo le ottimizzazioni e dovrebbe darti dei tempi un
po' piu` lunghi.
Saluti,
Marco
-- 
To email me, remove the no_ and _spam from my address.

 
Strano! a me funziona perfettamente anche dopo riprtuti lanci.
Come riprova ottengo tempi coerenti usando il comando di shell
$ time a.out
k=99999
4080001 time units (4.080000 seconds)
CLOCKS: 1000000.000000
real    0m4.155s
user    0m4.082s
sys     0m0.006s
Come vedi il tempo di user riportato da time e` lo stesso considerando 
che include anche le operazioni prima e dopo la tua misurazione.



compilo con cc -o aaa prova.c
Mi spiegheresti meglio la storia di questi diversi tempi sotto Unix?
Come li ottengo in C.
Inoltre, ho letto alcune cose, ma non riesco ad utilizzare la time in un
programma C.
Grazie

Scusa la mia domanda ma xchč ti interessa sapere il tempo di esecuzione del 
ciclo ?
ReDiCuori
-- 
-- 
L'uomo non sa perchč si innamora, l'uomo viene travolto e basta
---------------------------------------------------------
www.giordanoemilio.altervista.org
---------------------------------------------------------


Non mi serve sapere il tempo di quel ciclo. Quel codice lo usato come
esempio.
Devo misurare il tempo di esecuzione di una metaeuristica che ho scritto per
fare dei confronti con altre varianti

 programma C.
Semplicissimo. Anche qui ti rimando alla pagina di manuale
o al Kernighan & Ritchie.
   #include <time.h>
   time_t cur_time;
   cur_time = time(NULL);
In breve: time() ritorna il timestamp corrente. Se non e` disponibile,
ritorna -1. Se l'unico parametro (un puntatore a time_t) e` _diverso_
da NULL, allora la time() ci scrive dentro il valore di ritorno.
Quindi:
   time_t cur_time1, cur_time2;
   cur_time1 = time(&cur_time2);
   if ( cur_time1 == cur_time2 ) {
       /* Il flusso finisce _sempre_ qui dentro
        * perche' la condizione dell'if e` sempre
        * verificata */


 programma C.
time_t now = time(NULL);
oppure:
time_t now;
time(&now);
time() ritorna il numero di secondi trascorsi adu un certo giorno del 
passato (1-1-1970 per ambienti Unix, 1-1-1980 per ambienti MS).
E` in pratica il modo per ottenere la data corrente.


 time(&now);
Aggiungo
   time_t now1, now2;
   now1 = time(&now2);
ora dovrebbe sempre essere now1 == now2
