Newsgroup: it.comp.lang.c
Titolo: controllare se una tra due variabili è 0

ciao a tutti!
una mia curiosità:
dati due unsigned int a,b:
qual è il metodo più veloce per controllare se anche solo uno dei due
è==0?
metodo 1: if(a==0 || b==0);
metodo 2: if((a*b)==0);
metodo 3: if(!(a&b));
da qualche piccolo test che ho fatto sembra che la classifica dal più
veloce al più lento sia:
1. metodo 1
2. metodo 3
3. metodo 2
questo sia con o senza ottimizzazioni (gcc -O0 e gcc -O3)
come mai?
ho provato a guardare i file asm generati dal gcc (gcc -S) ma non
conosco l'assembler e non ho capito quasi niente. (a parte che quelli
con -O3 sono molto più corti)
ciao,
Costa

 come mai?
Ma perche' fai dei test di velocita' su delle sciocchezze simili ?!?
Pensa a velocizzare gli algoritmi e non i confronti!!!
Stai perdendo tempo. Vai per la versione piu' leggibile!
Tommy


In debug, visualizza il codice in assembler e guarda quante istruzioni
generano i tre casi.
Poi se vuoi essere ancora piu' pignolo puoi contare i cicli macchina che
ognuno dei tre blocchi di codice assembler ci mette ad essere eseguito
(sempre che non venga ottimizzato il codice per essere eseguito in parallelo
come su alcuni DSP)
Ciao
Giuseppe

 come su alcuni DSP)
Che senso ha fare tutto questo ?!?!?
Se invece di perdere tempo a scrivere l'if piu' veloce, impiegasse tempo a
pensare a quello che sta scrivendo si renderebbe conto che il metodo 3 e'
sbagliato.
Non si ottimizzano le istruzioni singole con tempi costanti!
Si ottimizzano gli algoritmi!
Tommy

sbagliato.
Pienamente concorde a proposito del punto 3.
Pero' in certi casi conviene scrivere il codice in un modo  piuttosto
che  in  un  altro,  perche' il compilatore e il linker convertono il
tutto in assembler in modo diverso.
Talvolta puo' essere  importante  recuperare  due  o  tre  istruzioni
assembler,  soprattutto  se  si  tratta  di  codice  che  deve rigare
velocemente, oppure frequentemente.
Bye
GIGI
-- 
   THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
visit my home page:
http://web.tiscali.it/KilometroZero

 velocemente, oppure frequentemente.
Tipo in un :
for(;;){
    if( (a==0) || (b==0) ){
        // DO NOTHING
    }
}
Si, capisco quello che dici anche se non lo vedo cosi' fondamentale.
Un buon optimiser produrra' un codice uguale anche se cerchi di renderla
piu' veloce, che ne so con:
if( (!a) || (!b) )
Ad ogni modo se il lavoro del optimiser non ti soddisfa, la cosa migliore e'
scrivere tale pezzo in assembly.
Poi lui e' liberissimo di divertirsi a giocare con gli operatori logici e
provare cose tipo:
if( (!a) || (!b) )
if(!(a&&b))
etc...
Tommy

 sbagliato.
Chiedere e' lecito rispondere e' creanza.
E' stata posta una domanda ed e' stata data una risposta mi pare sensata.
Quello che Costa vuole fare non mi interessa minimamente.
Ciao
Giuseppe

 Giuseppe
Io non ho messo in discussione la tua risposta... ho solo dato la mia
opinione che fare tutto cio' e' inutile.
Tommy

 Stai perdendo tempo. Vai per la versione piu' leggibile!
so bene che sono sciocchezze e infatti quello che ho chiesto non ha a
che vedere con alcun programma o codice... come avevo premesso era solo
una **curiosità**, e i miei cosiddetti test una cavolata giusto per
**buttare** un po' di tempo!
ciao,
Costa


Parti dal presupposta che il codice debba girare su un x86 (che ad oggi
pistano che e' un piacere), ma se invece dovesse girare su un micro da
qualche Mhz, risparmiare cicli potrebbe essere necessario!
Keita'

 opinione che fare tutto cio' e' inutile.
Sei troppo categorico.
Il C è un linguaggio oggi usato su un incredibile varietà di piattaforme,
dai P4 agli embedded a 16 bit (o meno...).
Non escluderei a priori che un'ottimizzazione del genere si posssa
rendere necessaria, anzi...
Per il resto concordo che la procedura 'dovrebbe' essere:
1- scrivo il codice più chiaro possibile.
2- Se ho necessità di ottimizzare, ottimizzo innanzitutto gli algoritmi.
3- Se ho ancora necessità di ottimizzare, passo ai blocchi di istruzioni
4- Se ho ancora necessità di ottimizzare, passo all'assembler
(5- Se ho ancora necessità di ottimizzare, passo il progetto a qualcun altro
:-))
--
Gerolamo

 :-))
Io penso fosse cosi' una volta.
Ora penso si tenda a saltare il punto 3 e si passi direttamente al 4.
Gli optimisers fanno un buon lavoro su compiler e su cross-compiler... se
non ti basta passi all'assembly. E' diventato inutile ottimizzare una
singola istruzione come quella postata!
Poi ripeto, questo e' quello che penso io.
Per il resto concordo con te.
Tommy