Funkcja Dll jest szybsza niż normalne wywołanie funkcji?

Question

Testowałem prędkość wyeksportowanej funkcji w bibliotece DLL i normalnej funkcji. Jak to możliwe, że wyeksportowana funkcja w bibliotece DLL jest dużo szybsza?

100000000 function calls in a DLL cost: 0.572682 seconds 
100000000 normal function class cost: 2.75258 seconds 

Jest to funkcja w DLL:

extern "C" __declspec (dllexport) int example() 
{ 
    return 1; 
} 

To normalne wywołanie funkcji:

int example() 
{ 
    return 1; 
} 

ten sposób przetestować go:

int main() 
{ 
    LARGE_INTEGER frequention; 
    LARGE_INTEGER dllCallStart,dllCallStop; 
    LARGE_INTEGER normalStart,normalStop; 
    int resultCalculation; 

    //Initialize the Timer 
    ::QueryPerformanceFrequency(&frequention); 
    double frequency = frequention.QuadPart; 
    double secondsElapsedDll = 0; 
    double secondsElapsedNormal = 0; 

    //Load the Dll 
    HINSTANCE hDll = LoadLibraryA("example.dll"); 

    if(!hDll) 
    { 
     cout << "Dll error!" << endl; 
     return 0; 
    } 

    dllFunction = (testFunction)GetProcAddress(hDll, "example"); 

    if(!dllFunction) 
    { 
     cout << "Dll function error!" << endl; 
     return 0; 
    } 

    //Dll 
    resultCalculation = 0; 
    ::QueryPerformanceCounter(&dllCallStart); 
    for(int i = 0; i < 100000000; i++) 
     resultCalculation += dllFunction(); 
    ::QueryPerformanceCounter(&dllCallStop); 

    Sleep(100); 

    //Normal 
    resultCalculation = 0; 
    ::QueryPerformanceCounter(&normalStart); 
    for(int i = 0; i < 100000000; i++) 
     resultCalculation += example(); 
    ::QueryPerformanceCounter(&normalStop); 

    //Calculate the result time 
    secondsElapsedDll = ((dllCallStop.QuadPart - dllCallStart.QuadPart)/frequency); 
    secondsElapsedNormal = ((normalStop.QuadPart - normalStart.QuadPart)/frequency); 

    //Output 
    cout << "Dll: " << secondsElapsedDll << endl; //0.572682 
    cout << "Normal: " << secondsElapsedNormal << endl; //2.75258 

    return 0; 
} 

Testuję tylko prędkość wywoływania funkcji, ge adres można zrobić przy uruchomieniu. Tak więc utracony spektakl nie ma znaczenia.

Answer 1

W przypadku bardzo małej funkcji różnica polega na tym, że funkcja zwraca/czyści argumenty.

Jednak nie powinno to mieć większego znaczenia. Myślę, że kompilator zdaje sobie sprawę, że twoja funkcja nic nie robi z wynikiemCalcuation i optymalizuje go. Spróbuj użyć dwóch różnych zmiennych i wydrukuj ich wartość później.