La lingua di assembly inline è più lenta del codice C ++ nativo?

Ho provato a confrontare le prestazioni del linguaggio assembly inline e del codice C ++, quindi ho scritto una funzione che aggiunge due array di dimensione 2000 per 100000 volte. Ecco il codice:

#define TIMES 100000 void calcuC(int *x,int *y,int length) { for(int i = 0; i < TIMES; i++) { for(int j = 0; j < length; j++) x[j] += y[j]; } } void calcuAsm(int *x,int *y,int lengthOfArray) { __asm { mov edi,TIMES start: mov esi,0 mov ecx,lengthOfArray label: mov edx,x push edx mov eax,DWORD PTR [edx + esi*4] mov edx,y mov ebx,DWORD PTR [edx + esi*4] add eax,ebx pop edx mov [edx + esi*4],eax inc esi loop label dec edi cmp edi,0 jnz start }; } 

Ecco il main() :

 int main() { bool errorOccured = false; setbuf(stdout,NULL); int *xC,*xAsm,*yC,*yAsm; xC = new int[2000]; xAsm = new int[2000]; yC = new int[2000]; yAsm = new int[2000]; for(int i = 0; i < 2000; i++) { xC[i] = 0; xAsm[i] = 0; yC[i] = i; yAsm[i] = i; } time_t start = clock(); calcuC(xC,yC,2000); // calcuAsm(xAsm,yAsm,2000); // for(int i = 0; i < 2000; i++) // { // if(xC[i] != xAsm[i]) // { // cout<<"xC["<<i<<"]="<<xC[i]<<" "<<"xAsm["<<i<<"]="<<xAsm[i]<<endl; // errorOccured = true; // break; // } // } // if(errorOccured) // cout<<"Error occurs!"<<endl; // else // cout<<"Works fine!"<<endl; time_t end = clock(); // cout<<"time = "<<(float)(end - start) / CLOCKS_PER_SEC<<"\n"; cout<<"time = "<<end - start<<endl; return 0; } 

Quindi eseguo il programma cinque volte per ottenere i cicli del processore, che potrebbe essere visto come il tempo. Ogni volta chiamo solo una delle funzioni sopra menzionate.

E qui arriva il risultato.

Funzione della versione di assembly:

 Debug Release --------------- 732 668 733 680 659 672 667 675 684 694 Average: 677 

Funzione della versione C ++:

 Debug Release ----------------- 1068 168 999 166 1072 231 1002 166 1114 183 Average: 182 

Il codice C ++ in modalità di rilascio è quasi 3.7 volte più veloce del codice assembly. Perché?

Immagino che il codice assembly che ho scritto non sia efficace come quelli generati da GCC. È difficile per un programmatore comune come me scrivere codice più velocemente del suo avversario generato da un compilatore. Ciò significa che non dovrei fidarmi delle prestazioni del linguaggio assembly scritto dalle mie mani, concentrarsi sul C ++ e dimenticare il linguaggio assembly?