La chiamata della funzione Dll è più veloce di una normale chiamata di funzione?

Question

Stavo testando la velocità di una funzione esportata in una DLL e una funzione normale. Com'è possibile che una funzione esportata in una DLL sia molto più veloce?

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

Questa è la funzione nella DLL:

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

Questa è la normale chiamata di funzione:

int example() 
{ 
    return 1; 
} 

Ecco come ho provarlo:

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; 
} 

Ho solo provato la funzione chiamata velocità, ge l'indirizzo può essere fatto all'avvio. Quindi la performance persa di quello non mater.

Answer 1

Per una funzione molto piccola, la differenza è nel modo in cui una funzione restituisce/pulisce gli argomenti.

Tuttavia, questo non dovrebbe fare molta differenza. Penso che il compilatore si renda conto che la tua funzione non fa nulla con resultCalcuation e lo ottimizza. Prova a utilizzare due variabili diverse e poi a stampare il loro valore.