Newsgroup: it.comp.lang.c
Titolo: Calcolo del tempo di esecuzione di un programma.

Ciao a tutti.
Il programma che posto di seguito esegue, per molte volte, prima il 
prodotto tra due float e poi il prodotto tra due double, e calcola, in 
entrambi i casi, il tempo di utilizzo del processore (funzione clock) ed 
il tempo reale di esecuzione delle operazioni (funzione time). 
Vorei chiedervi come mai, secondo voi, quando esegue il prodotto tra 
double, il tempo di utilizzo del processore risulta maggiore del tempo 
reale di esecuzione del programma. Può essere dovuto all'approssimazione 
non troppo raffinata effettuata da clock?
Vi ringrazio e vi lascio al codice.
Bizio.
***
Nel file GaraFloatDouble.c
//Esegue lo stesso prodotto molte volte su una coppia di float prima e 
di double poi.
//Calcola il tempo di esecuzione di entrambi i cicli.
#include <stdio.h>
#include "./lib/include/u_lib.h"
#define N 2000000000 //Numero di prodotti da eseguire ogni volta.
int main(void) {
 float a, b = 3.333, c = 5.555; //due numeri a caso.
 double x, y = 3.333, z = 5.555;  //Vedi sopra...
 int i;
 printf ("Numero di prodotti: %d\n", N);
 AvviaCronometro();
 for (i = 0; i < N; ++i)
  a = b * c;
 printf("Tipo float.\n");
 StampaTempo();
  for (i = 0; i < N; ++i)
  x = y * z;
 printf("Tipo double.\n");
 StampaTempo();
 printf("Tempo totale: \n");
 StampaTempoTotale();
 return 0;
}
***
Nel file tieniiltempo.c
//Funzioni che consentono di fornire una stima del tempo di esecuzione 
dei programmi C.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAXSTRING 100
typedef struct tieniiltempo { //Visibile solo in questo file.
 clock_t ClockIniziale; //Tempo iniziale di utilizzo del processore da 
parte del programma.
 clock_t ClockSalvato; //Tempo corrente di utilizzo del processore da 
parte del programma.
 time_t TempoIniziale; //Tempo iniziale per misurazione del tempo di 
esecuzione del programma.
 time_t TempoSalvato; //Tempo corrente per misurazione del tempo di 
esecuzione del programma.
 //Tempo di esecuzione corrente = TempoIniziale - TempoSalvato.
} tieniiltempo; //Utilizzata per la comunicazione tra le funzioni 
definite in questo file.
static tieniiltempo tt; //Visibile solo in questo file.
void AvviaCronometro(void) {
//Fa virtualmente partire il cronometraggio del tempo di esecuzione del 
programma, inizializzando la struct tt.
 tt.ClockIniziale = tt.ClockSalvato = clock();
 tt.TempoIniziale = tt.TempoSalvato = time(NULL);
}
double StampaTempo(void) {
//Stampa il tempo che intercorre tra due aggiornamenti consecutivi di 
tt.ClockSalvato e tt.TempoSalvato.
//Viene chiamata all'inizio e alla fine del blocco di istruzioni da 
cronometrare.
 char s1[MAXSTRING], s2[MAXSTRING]; //Utilizzate per calcolare 
l'ampiezza del campo delle printf.
 int AmpiezzaCampo; //Ampiezza del campo delle printf.
 int amp1, amp2; //La più grande di queste sarà assegnata ad 
AmpiezzaCampo.
 double TempoProcessore, TempoReale; //Differenze tra i valori correnti 
e quelli salvati (vedere più avanti).
 //Le prossime due istruzioni calcolano il tempo di utilizzo del 
processore e reale.
 TempoProcessore = (clock() - tt.ClockSalvato) / (double) 
CLOCKS_PER_SEC;
 TempoReale = difftime(time(NULL), tt.TempoSalvato);
 tt.ClockSalvato = clock();
 tt.TempoSalvato = time(NULL);
 //Calcolo dell'ampiezza del campo per le printf.
 amp1 = sprintf(s1, "%.1g", TempoProcessore);
 amp2 = sprintf(s2, "%.1g", TempoReale);
 AmpiezzaCampo = (amp1 >= amp2) ? amp1 : amp2;
 printf("%s%*.1f%s\n", "Tempo di utilizzo del processore: ", 
AmpiezzaCampo, TempoProcessore, " secondi.");
 printf("%s%*.1f%s\n", "Tempo di esecuzione del programma: ", 
AmpiezzaCampo, TempoReale, " secondi.");
 return TempoProcessore;
}
double StampaTempoTotale(void) {
//Stampa il tempo reale e di utilizzo del processore trascorso 
dall'inizio dell'esecuzione del programma.
 char s1[MAXSTRING], s2[MAXSTRING]; //Utilizzate per calcolare 
l'ampiezza del campo delle printf.
 int AmpiezzaCampo; //Ampiezza del campo delle printf.
 int amp1, amp2; //La più grande di queste sarà assegnata ad 
AmpiezzaCampo.
 double TempoProcessore, TempoReale; //Differenze tra i valori correnti 
e quelli iniziali (vedere più avanti).
 //Le prossime due istruzioni calcolano il tempo totale di utilizzo del 
processore e reale.
 TempoProcessore = (clock() - tt.ClockIniziale) / (double) 
CLOCKS_PER_SEC;
 TempoReale = difftime(time(NULL), tt.TempoIniziale);
 //In questa funzione non ho bisogno di aggiornare tt.ClockSalvato e 
tt.TempoSalvato.
 //Calcolo dell'ampiezza del campo per le printf.
 amp1 = sprintf(s1, "%.1g", TempoProcessore);
 amp2 = sprintf(s2, "%.1g", TempoReale);
 AmpiezzaCampo = (amp1 >= amp2) ? amp1 : amp2;
 printf("%s%*.1f%s\n", "Tempo totale di utilizzo del processore: ", 
AmpiezzaCampo, TempoProcessore, " secondi.");
 printf("%s%*.1f%s\n", "Tempo totale di esecuzione del programma: ", 
AmpiezzaCampo, TempoReale, " secondi.");
 return TempoProcessore;
}


Ti dò un indizio: 1- prova invertire i test, facendo prima il calcolo
con i double e poi con i float,  2- prova a far correre più volte il
programma e confronta i tempi
Ciao!