Newsgroup: it.comp.lang.c++
Titolo: clock_t e la temporizzazione

Ciao a tutti,
sto lavorando con un blocco di codice.
Ho 2 var di tipo clock_t        
inizio_idle = clock();
[...]
// blocco di lavoro
[...]
fine_idle = clock();
alla fine vorrei sapere la differenza tra inizio_idle e fine_idle ma non so
come stamparlo con la printf...
ad es: printf("diff: %lf\n", fine_idle - inizio_idle);
idee? ;)
-- 
Carlo

 Cingar
Se tratti clock_t come long non hai l'informazione completa. clock_t è
assolutamente da trattarsi come double, altrimenti non stampi i decimali.
In più non ho capito che c'entra la nota sui 2.9 miliardi di anni! Leggi il
manuale:
...The value returned by clock() may wrap around on some implementations.
For example, on a machine with 32-bit values for clock_t, it wraps after
2147 seconds or 36 minutes...
quindi restituirà lo stesso valore ogni 72 minuti.
Ciao,
fabiomdf
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/


A proposito, come ti è stato consigliato da Mattia, non dimenticare di
dividere per CLOCKS_PER_SEC e fare il cast a double:
 #include <time.h>
 clock_t c1, c2;
 c1 = clock();
 c2 = clock();
 printf("clock(): %.2f\n", (double)(c2 - c1) / CLOCKS_PER_SEC);
Ho letto, nello stesso thread ma in altro post, che hai avuto problemi con
la soluzione di Mattia e questo non è possibile. Ricopia il soprascritto
codice esattamente come si trova, compilalo con un compilatore decente (gcc,
ovvio no?) e ti assicuro che non avrai problemi.
Vuoi sapere che cosa è "CLOCKS_PER_SEC"?
// "your_path_to_linux_source/include/linux/sched.h":
#define HZ 1000 /* Internal kernel timer frequency */
#define USER_HZ 100 /* .. some user interfaces are in "ticks" */
#define CLOCKS_PER_SEC ( USER_HZ ) /* like times() */


  printf("clock(): %.2f\n", (double)(c2 - c1) / CLOCKS_PER_SEC);
qsto e' il mio output:
Inizio IDLE: 930000.000000, fine IDLE 940000.000000, differenza: 0.010000
Inizio IDLE: 1550000.000000, fine IDLE 1550000.000000, differenza: 0.000000
Inizio IDLE: 2040000.000000, fine IDLE 2050000.000000, differenza: 0.010000
Inizio IDLE: 2650000.000000, fine IDLE 2660000.000000, differenza: 0.010000
Inizio IDLE: 3170000.000000, fine IDLE 3180000.000000, differenza: 0.010000
1) 
perche' dici che devo dividere per CLOCKS_PER_SEC ? A me serve sapere quanti
colpi di clock passano.
2)
ma clock() mi ritorna i colpi di clock? A me serve una funzione che
restituisca i colpi di clock o almeno i millisecondi che passano...
-- 
Carlo

 restituisca i colpi di clock o almeno i millisecondi che passano...
Eh, quella ti restituisce i secondi (era abbastanza intuibile...), 
immagino che moltiplicare per 1000 non sia una grande difficolta'.
E comunque a me la frase "colpi di clock" mi fa venire in mente 
un'immagine di mazzate compiute con un orologio... :-)
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Jabber: RedGlow  - Linux registered user 299762 @ machine 213003

 restituisca i colpi di clock o almeno i millisecondi che passano...
Se sei su un pc 386 (pentium e simili) cerca google con "rdtsc". Ci
dovrebbero essere librerie che fanno il timing con il clock del
processore e possono essere calibrate per darti i milli/micro/nano
seconndi. Pero` fai attenzione che se non lavori su DOS il risultato che
otterresti non e` solo quello del tuo processo, in background hai altri
processi che si spartiscono anche per microsecondi il tempo CPU.
Altrimenti, cerca nel tuo ambiente di sviluppo qualcosa che abbia a che
fare con "profiling".
Ciao
-- 
int

 2147 seconds or 36 minutes...
... possono bastare molto meno di 68 anni perché la sottrazione perda
significato.
Addirittura, potrebbe non averne mai di significato: lo standard dice
che un compilatore pazzo potrebbe implementarla così:
    clock_t clock (void)
    {
        return -1;
    }
--
Cingar

 Cingar


 Carlo
