è meglio evitare l'uso dell'operatore mod quando possibile?

Question

Suppongo che il calcolo del modulo di un numero sia un'operazione alquanto costosa, almeno rispetto ai semplici test aritmetici (come vedere se un numero supera la lunghezza di un array). Se questo è davvero il caso, è più efficiente per sostituire, ad esempio, il seguente codice:

res = array[(i + 1) % len]; 

con il seguente? :

res = array[(i + 1 == len) ? 0 : i + 1]; 

Il primo è più facile per gli occhi, ma mi chiedo se il secondo potrebbe essere più efficiente. Se è così, potrei aspettarmi un compilatore ottimizzante per sostituire il primo frammento con il secondo, quando viene utilizzato un linguaggio compilato?

Ovviamente questa "ottimizzazione" (se si tratta in effetti di un'ottimizzazione) non funziona in tutti i casi (in questo caso funziona solo se i+1 non è mai più di len).

Answer 1

Il mio consiglio generale è il seguente. Usa la versione che ritieni più facile per gli occhi e quindi profila il tuo intero sistema. Ottimizza solo quelle parti del codice che il profiler contrassegna come colli di bottiglia. Scommetto il mio dollaro in meno che l'operatore modulo non sarà tra loro.

Per quanto riguarda l'esempio specifico, solo il benchmarking può indicare quale sia più veloce sulla propria architettura specifica utilizzando il proprio compilatore specifico. È potenzialmente possibile sostituire modulo con branching ed è tutto fuorché ovvio che sarebbe più veloce.

Answer 2

Modulo può essere eseguito con un'istruzione a processore singolo sulla maggior parte delle architetture (ad esempio DIV su x86). Tuttavia è probabile un'ottimizzazione prematura per ciò di cui hai bisogno.

Answer 3

Consigli per evitare% (modulo) Operatore, http://embeddedgurus.com/stack-overflow/2011/02/efficient-c-tip-13-use-the-modulus-operator-with-caution

Answer 4

Qualche semplice misura:

#include <stdio.h> 
#include <stdlib.h> 

int main(int argc, char *argv[]) 
{ 
    int test = atoi(argv[1]); 
    int divisor = atoi(argv[2]); 
    int iterations = atoi(argv[3]); 

    int a = 0; 

    if (test == 0) { 
     for (int i = 0; i < iterations; i++) 
      a = (a + 1) % divisor; 
    } else if (test == 1) { 
     for (int i = 0; i < iterations; i++) 
      a = a + 1 == divisor ? 0 : a + 1; 
    } 

    printf("%d\n", a); 
} 

compilazione sia con gcc o clang con -O3, e in esecuzione time ./a.out 0 42 1000000000 (versione modulo) o time ./a.out 1 42 1000000000 (confronto versione)

• 6,25 secondi runtime utente per la versione modulo,
• 1,03 secondi per la versione di confronto.

(usando gcc 5.2.1 o 3.6.2 clang; Intel Core i5-4690K @ 3.50GHz; Linux a 64 bit)

Ciò significa che è probabilmente una buona idea di utilizzare la versione confronto .