Performance Swaping ganze Zahlen vs Doppel

Question

Aus irgendeinem Grund ist mein Code in der Lage, Swaps auf Doppel schneller als auf den ganzen Zahlen durchzuführen. Ich habe keine Ahnung, warum das passieren würde.

Auf meinem Computer ist die doppelte Swap-Schleife 11-mal schneller als die Integer-Swap-Schleife. Welche Eigenschaft von Double/Integer macht sie so?

Testaufbau

• Visual Studio 2012 x64
• CPU Core i7 950
• Bauen als Release und laufen exe direkt, VS Debug Haken Skew Dinge

Ausgabe:

Process time for ints 1.438 secs

Process time for doubles 0.125 secs

#include <iostream> 
#include <ctime> 
using namespace std; 

#define N 2000000000 

void swap_i(int *x, int *y) { 
    int tmp = *x; 
    *x = *y; 
    *y = tmp; 
} 

void swap_d(double *x, double *y) { 
    double tmp = *x; 
    *x = *y; 
    *y = tmp; 
} 

int main() { 
    int a = 1, b = 2; 
    double d = 1.0, e = 2.0, iTime, dTime; 
    clock_t c0, c1; 

    // Time int swaps 
    c0 = clock(); 
    for (int i = 0; i < N; i++) { 
     swap_i(&a, &b); 
    } 
    c1 = clock(); 
    iTime = (double)(c1-c0)/CLOCKS_PER_SEC; 

    // Time double swaps 
    c0 = clock(); 
    for (int i = 0; i < N; i++) { 
     swap_d(&d, &e); 
    } 
    c1 = clock(); 
    dTime = (double)(c1-c0)/CLOCKS_PER_SEC; 

    cout << "Process time for ints " << iTime << " secs" << endl; 
    cout << "Process time for doubles " << dTime << " secs" << endl; 
} 

Es scheint, dass VS nur eine der Schleifen optimiert wie Hütten erläutert.

Wenn ich alle Compiler-Optimierungen zu deaktivieren und in den Schleifen meinen Swap-Code inline habe, habe ich die folgenden Ergebnisse (Ich wechselte auch meine Timer std :: Chrono :: high_resolution_clock):

Process time for ints 1449 ms

Process time for doubles 1248 ms

Answer 1

Sie können die Antwort finden, indem Sie auf die generierte Baugruppe schauen.

Mit Visual C++ 2012 (32-Bit-Version Build) der Körper von swap_i ist drei mov Anweisungen, aber der Körper swap_d ist vollständig zu einer leeren Schleife optimiert. Der Compiler ist schlau genug, um zu sehen, dass eine gerade Anzahl von Swaps keine sichtbaren Auswirkungen hat. Ich weiß nicht, warum es nicht das gleiche mit der int Schleife macht.

Ändern nur #define N 2000000000 zu #define N 2000000001 und Wiederaufbau führt die swap_d Körper zu tatsächlichen Arbeit durchführen. Die Endzeiten sind nahe an meiner Maschine, wobei swap_d ungefähr 3% langsamer ist.