Newsgroup: it.comp.lang.c
Titolo: I float più veloci dei (long) int?

Stavo facendo delle prove con Dev-C++, per usare GetTickCount() e vedere 
quanto tempo ci mette il mio pc a fare 100 mln di moltiplicazioni.
Ho scrito questa piccola funzione:
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
int main(int argc, char *argv[])
{
   unsigned long t=0;
   float f1=1, f2=1;
   unsigned long i=0;
   t=GetTickCount();
   for(i=0; i<100000000; i++)
     f1*=f2;
   t=GetTickCount()-t;
   printf("Attesa: %umsec", t);
   getchar();
   return 0;
}
che mi dice che l'attesa č stata di 1437msec.
Se cambio le variabili f1 e f2 in unsigned int oppure unsigned longint, 
l'output diventa di 1562msec.
Ma la moltiplicazione fra float č piů veloce della moltiplicazione fra long?
-- 
Quando noi ignoranti eravamo di piů, tutto era piů bello (A. Celentano).
  ___   _   ___ _  _______   _______ ___
|   \ /_\ | _ \ |/ / _ ) \ / /_   _| __|
| |) / _ \|   / ' <| _ \\ V /  | | | _|
|___/_/ \_\_|_\_|\_\___/ |_|   |_| |___|

 Ma la moltiplicazione fra float è più veloce della moltiplicazione fra
long?
Con il VC++ .NET 2003 il tempo di attesa e' in entrambi i casi di 0 msec,
grazie al fatto che il miglior ottimizzatore capisce che non serve a nulla
fare tutto cio' e... decide di sua spontanea volonta' di non fare nulla (a)
anche perche' il calcolo e' 1*1 in un loop che fara' sempre 1.... (b) inolte
il valore di f1 non viene usato.
Come fai in modo che sia (a) che (b) vengano risolte allora di fatto esegue
qualche cosa... quindi ad esempio con:
float f1=1, f2=3;
e poi stampando il valore alla fine:
printf("%f\n",f1);
Ovviamente il tuo calcolo crea pero' un overflow....
Su un XP3200+ :
Ad ogni modo il tempo di attesa e' di 184 msec.
Cambiando in unsigned long int il tempo di attesa e' di: 91 msec
Cambiando in double e' di: 184 msec
Cambiando in long double e' di: 186 msec
Cambiando in unsigned __int64 e' di: 1,021 msec
Ovviamente tutti i risultati sono errati a causa di overflow.
Ovviamente il tuo test non dimostra nulla, puoi prendere tutti i tempi che
ti ho dato e buttarli via...
Bisogna fare bechmarks piu' accurati e meno banali per misurare le
prestazioni.
Tommy

 il valore di f1 non viene usato.
Si ma io non ho usato VC++ .NET 2003, bensì Dev-C++.
E il tempo di attesa c'è stato, perchè le moltiplicazioni me le ha 
eseguite, e ci ha impiegato prima 1437 poi 1562 millisecondi.
Se avessi avuto un ottimizzatore ottimo come dici tu, in ogni caso 
avrebbe prevenuto le moltiplicazioni in entrambi i casi, lasciando 
semplicemente che il ciclo venisse ripetuto a vuoto.
Però così non è stato... e ci ho impiegato 1,4 secondi prima e 1,5 dopo.
Potrei anche fare così:
unsigned long int f1=3, f2=1;
for(i=0; i<100000000; i++)
   f1*=f2;
in modo da fare sempre 3*1, ma non credo cambierebbe molto.
Il succo però è: il compilatore che ho usato NON ha notato di eseguire 
sempre 1*1 e lo ha calcolato di continuo.
Domanda: perchè ci ha impiegato tempi diversi e rallentando con 
l'utilizzo di long int?
-- 
Quando noi ignoranti eravamo di più, tutto era più bello (A. Celentano).


 l'utilizzo di long int?
Perche' il test non e' attendibile... ok, prendi l'eseguibile, disassemblalo
e poi guarda le istruzioni assembly per il long int e poi per il float. La
risposta giace nel codice binario, se lo disassembli capirai. Non esistono
magie in informatica, il compute esegue cio' che gli dici, ma quando usi un
compilatore con ottimizzatore spesso non sai quello che gli stai dicendo ;-)
Tommy