2015-05-01 13 views
9

Mam kawałek kodu, który działa 2x szybciej na Windows niż na Linuksie. Oto razy mierzone:Kod działa 2x szybciej na Windows niż na Linuksie

g++ -Ofast -march=native -m64 
    29.1123 
g++ -Ofast -march=native 
    29.0497 
clang++ -Ofast -march=native 
    28.9192 
visual studio 2013 Debug 32b 
    13.8802 
visual studio 2013 Release 32b 
    12.5569 

naprawdę wydaje się być zbyt wielka różnica.

tutaj kod:

#include <iostream> 
#include <map> 
#include <chrono> 
static std::size_t Count = 1000; 

static std::size_t MaxNum = 50000000; 

bool IsPrime(std::size_t num) 
{ 
    for (std::size_t i = 2; i < num; i++) 
    { 
     if (num % i == 0) 
      return false; 
    } 
    return true; 
} 

int main() 
{ 
    auto start = std::chrono::steady_clock::now(); 
    std::map<std::size_t, bool> value; 
    for (std::size_t i = 0; i < Count; i++) 
    { 
     value[i] = IsPrime(i); 
     value[MaxNum - i] = IsPrime(MaxNum - i); 
    } 
    std::chrono::duration<double> serialTime = std::chrono::steady_clock::now() - start; 
    std::cout << "Serial time = " << serialTime.count() << std::endl; 

    system("pause"); 
    return 0; 
} 

Wszystko to zmierzono w tej samej maszynie okien 8 vs Linux 3.19.5 (gcc 4.9.2, szczęk 3.5.0). Zarówno linux, jak i windows są 64-bitowe.

Jaki może być tego powód? Niektóre problemy z programem planującym?

EDIT: Było to spowodowane przez budowę 32b binarnych na okna w przeciwieństwie do 64b binariów na Linux, oto 64b numery do okien:

Visual studio 2013 Debug 64b 
    29.1985 
Visual studio 2013 Release 64b 
    29.7469 
+0

Byłoby interesujące, gdybyś mógł podać niektóre dissasemblies z IsPrime. I wyselekcjonuj nieco ustawienia optymalizacji. –

+0

Spróbuj po prostu wywołać 'IsPrime' bez zapisywania wyniku w mapie' value'. A następnie spróbuj zapisać niepoprawne wartości w mapie 'value' bez wywoływania' IsPrime' i zobacz, co się stanie. –

+0

'VS2013' nie używa' QueryPerformanceCounter' dla 'std :: steady_clock': http://stackoverflow.com/a/13266477/2502409 – Nazar554

Odpowiedz

4

Nie mów czy systemów operacyjnych Windows/Linux są 32 lub 64-bitowe.

W 64-bitowym komputerze z systemem Linux, jeśli zmienisz size_t na int, okaże się, że czasy wykonania spadają na Linuksie do wartości podobnej do tych, które masz w systemie Windows.

size_t to int32 na win32, int64 na win64.

EDYCJA: właśnie widziałeś twój demontaż okien.

Twój system operacyjny Windows jest 32-bitową odmianą (lub przynajmniej skompilowaną dla wersji 32-bitowej).

+0

Masz rację. Nie zdawałem sobie sprawy, że domyślnie buduję binaria 64b na Linuksie (dlatego próbowałem przekazać -m64 do gcc). – hynner

+0

@hynner, chociaż muszę przyznać, że zaskoczyło mnie, że 64-bitowy kod jest o połowę szybszy! –

+2

Wiele algorytmów jest w rzeczywistości związanych z przepustowością pamięci. Jeśli używasz podwójnych typów wartości, ich użycie podczas czytania i pisania zajmuje dwa razy więcej czasu. –

Powiązane problemy