装配中的矩阵乘法

而不是在寻址模式下尝试将多个寄存器扩展为两个( which is impossible ),只需使用 add eax, 2 而不是 inc eax .

此外,由于输出矩阵使用32位 int ,你应该做32位数学。您将在DI中生成一个值,然后用第66行存储该值加上EDI高半部分中的任何垃圾。

有点像 movsx esi, word ptr [rowstart + column]
movsx eax, word ptr [offset_in_column + row] / imul eax, esi

基于我认为你正在尝试做的,我认为你的算法可能是健全的。对于输出矩阵的每个元素,循环遍历一个矩阵中的列和另一个矩阵的行。因此,您只对输出矩阵的每个元素存储一次。不管你的循环是否真的这样做,IDK:分支有多么难看,这会伤到我的大脑 http://gcc.godbolt.org/ ).

嵌套循环的其他方法对于大型矩阵的性能可能更好或更差,但唯一真正好的方法(对于大型矩阵)是转置其中一个输入矩阵,以便可以一次循环两个矩阵中的连续内存元素(因为转置花费O(n^2)时间,但会加快重复遍历转置数组的O(n*3)步骤,因为它提供了更多缓存命中)。

谢谢大家。这是我最后的三嵌套循环和矩阵乘积代码。对于我测试的内容,它适用于任何矩阵和正负值:

void main()
{
    unsigned int m = 3; // numero di righe della prima matrice
    unsigned int n = 2; // numero di colonne della prima matrice
    unsigned int k = 4; // numero di colonne della seconda matrice
    short int mat1[] = { -1,-2, 4,5, 4,-2 }; // prima matrice
    short int mat2[] = { 2,0,0,0, 0,2,0,0 }; // seconda matrice
    int mat3[1024]; // matrice risultato

    __asm {

        lea eax, mat1       //load mat1
        lea edi, mat3       //load mat result
        push m

        Loop3 :             //extern loop
        lea ebx, mat2       //load here mat2 to start from the beginning when new result raw starts
            xor edx, edx    //sets to zero column counter set to zero when new result row starts

        Loop2 :             //middle loop, as long as k, mat2 columns 
        xor ecx, ecx        //sets to zero mat1 column counter every n multiplications

        Loop1 :             //inner loop
        call Compute        //calls sub program that calulates raw/column products
            inc ecx         //increase column counter
            cmp ecx, n      //check column counter
            jb Loop1        //if below loop1 again
            add ebx, 2      //if equal to n, inner loop is over, move mat2 position of one position
            inc edx         //increase mat2 column counter
            cmp edx, k      //chek mat2 column counter
            jb Loop2        //if below loop2 again
            imul esi, n, 2      //else calculate offset to skip to new raw in mat1
            add eax, esi        //...skip to new mat1 raw
            imul esi, k, 4      //calculate offset to skip to new raw in result matrix(mat3)
            add edi, esi        //...skip to new raw in mat3
            dec m               //a raw in mat1 has been done, decrease its counter
            cmp m, 0            //check how many raws has been done
            ja Loop3            //if more than zero, do extern loop again
            jmp Finale          //else algorithm is over

        Compute :               //calulates raw/column products
        movsx esi, WORD PTR[eax][ecx * 2]       
            push edi            //stores mat3 address to free edi counter
            push ecx            //stores the actual value of column counter to free ecx register
            mov edi, k          //calculates the offset in mat2...
            imul edi, ecx       //...
            movsx ecx, WORD PTR[ebx][edi * 2]   //mov the value of mat2 to ecx
            imul esi, ecx       //multiplicates values of mat1 ad mat2
            pop ecx             //set back column counter
            pop edi             //set back mat3 address
            cmp ecx, 0          //if ecx is zero...
            je First            //...is the first multiplication for this result value...
            add[edi][edx * 4], esi  //if not the first, add the value to current position

        Back :
        ret                     //in any case, comes back to loops...

        First :                 //...so move here the first value to which add the others
        mov[edi][edx * 4], esi  //moving value
            jmp Back

        Finale :        //the end
        pop m           //restore the original mat1 raw value to print the result matrix below

    }

    //Output on video

    {
        unsigned int i, j, h;

        printf("Product Matrix:\n");
        for (i = h = 0; i < m; i++) {
            for (j = 0; j < k; j++, h++)
                printf("%6d ", mat3[h]);
            printf("\n");
        }

    }
}

这只是我从stackoverflaw中的双嵌套循环开始编写的三嵌套循环的算法:

m = raws of first matrix
k = columns of second matrix
n = column of first matrix and raws of second matrix

x=0
Loop3:
y=0
Loop2:
z=0
Loop1:
compute...
z++
if(z<n)
   go to Loop1
y++
if(y < k)
   go to Loop2
x++
if(x < m)
   go to Loop3
Else go to the End