Czy procesorzy faktycznie obliczają mnożenie przez zero lub jeden? Czemu?

Question

Wersja krótka

W kolejnym wierszu:

aData[i] = aData[i] + (aOn * sin(i)); 

Jeśli aOn jest 0 lub 1, czy procesor wykonują mnożenie, czy też warunkowo wypracowania wyniku (0 dla 0, inne -wartość dla 1)?

The Long Version

szukam do algorytmu konsystencji wydajności, co częściowo wiąże się zajrzeć do skutku Branch Prediction.

Przypuszcza się, że ten kod:

for (i = 0; i < iNumSamples; i++) 
    aData[i] = aData[i] + (aOn * sin(i)); 

zapewnia bardziej stabilne wyniki niż kod (gdzie przewidywania rozgałęzień mogą destabilizować wydajności)

for (i = 0; i < iNumSamples; i++) 
{ 
    if (aOn) 
     aData[i] = aData[i] + sin(i); 
} 

z aOn jest albo 0 lub 1, i może przełączać podczas wykonywania pętli przez inny wątek.

W kalkulacji warunkowy (+ sin(i) w powyższym przykładzie) obejmuje więcej przetwarzania i jeśli warunek musi znajdować się w pętli (istnieje mnogość warunkach, nie tylko jednego, jak w przykładzie powyżej, również zmiany aOn powinny efekt natychmiast, a nie na pętlę).

Zignorowanie spójności wydajności, kompromis pomiędzy dwiema opcjami jest w czasie niezbędnym do wykonania instrukcji if i mnożenia.

Bez problemu można zauważyć, że jeśli procesor nie wykonałby faktycznego mnożenia dla wartości takich jak 1 i 0, pierwsza opcja mogłaby być rozwiązaniem wygrywa-wygrana (bez przewidywania rozgałęzień, lepsza wydajność).

Answer 1

Procesory wykonują regularne mnożenie z 0 s oraz 1 s.

Powód jest taki, że jeśli procesor sprawdzi przed 0 i 1 przed każdym obliczeniem, wprowadzenie warunku zajmie więcej cykli. Podczas gdy uzyskasz wydajność dla mnożników 0 i 1, stracisz wydajność dla dowolnych innych wartości (które są o wiele bardziej prawdopodobne).

Prosty program może okazać się w ten sposób:

#include <iostream> 
#include "cycle.h" 
#include "time.h" 

void Loop(float aCoefficient) 
{ 
    float iSum = 0.0f; 

    clock_t iStart, iEnd; 

    iStart = clock(); 
    for (int i = 0; i < 100000000; i++) 
    { 
     iSum += aCoefficient * rand(); 
    } 
    iEnd = clock(); 
    printf("Coefficient: %f: %li clock ticks\n", aCoefficient, iEnd - iStart); 
} 

int main(int argc, const char * argv[]) 
{ 
    Loop(0.0f); 
    Loop(1.0f); 
    Loop(0.25f); 

    return 0; 
} 

dla którego wyjście jest:

Coefficient: 0.000000: 1380620 clock ticks 
Coefficient: 1.000000: 1375345 clock ticks 
Coefficient: 0.250000: 1374483 clock ticks