Eu tentei comparar o desempenho da linguagem assembly embutida e do código C ++, então escrevi uma função que adiciona duas matrizes de tamanho 2000 por 100000 vezes. Aqui está o código:

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

Aqui está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;
}

Então eu executo o programa cinco vezes para obter os ciclos do processador, que podem ser vistos como tempo. Cada vez que chamo apenas uma das funções mencionadas acima.

E aqui vem o resultado.

Função da versão de montagem:

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

Função da versão C ++:

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

O código C ++ no modo de liberação é quase 3,7 vezes mais rápido que o código de montagem. Por quê

Acho que o código de montagem que escrevi não é tão eficaz quanto os gerados pelo GCC. É difícil para um programador comum como eu escrever código mais rápido que seu oponente gerado por um compilador. Isso significa que não devo confiar no desempenho da linguagem assembly escrita por minhas mãos, focar em C ++ e esquecer a linguagem assembly?