如何在 x86-64 程序集中交换二维数组的 2 个值

Question

我正在汇编 x86-64 中制作一个程序，该程序基于 c 中的以下 function 转置矩阵

void transpose_matrix_by_naive(int **matrix, const int matrixSize){

    int i, j, auxValue;

    for (i = 0; i < matrixSize; i++){
        for (j = 0; j < matrixSize; j++){
            if (i < j){
                auxValue = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = auxValue;
            }
        }
    }
}

创建矩阵我使用以下 function

void create_matrix(int ***matrix, const int matrixSize){

    int i;

    *matrix = (int **)malloc(matrixSize * sizeof(int *));
    for (i = 0; i < matrixSize; i++){
        (*matrix)[i] = (int *)malloc(matrixSize * sizeof(int));
    }    
}

asm 中的程序是

;extern void transpose_matrix_by_naive_in_asm(int **matrix, int matrixSize);
;                                                   RDI         RSI
section .text
    global transpose_matrix_by_naive_in_asm
transpose_matrix_by_naive_in_asm:
    mov RAX, 0
    mov RBX, 0
loop_for_i:
    loop_for_j:
        cmp RAX, RBX
        jl conditional_if
        return:
        inc RBX
        cmp RBX, RSI
        jne loop_for_j
    inc RAX
    cmp RAX, RSI
    jne loop_for_i
conditional_if:
    ;here I have to make a swap
    jmp return

我的问题是¿如何交换矩阵 [i] [j] 和矩阵 [j] [i] 的值？ 值得一提的是，我只使用方阵。

Answer 1

在 x86 汇编程序中，memory 中的两个值被简单地交换为

 mov eax, [rdi]
 mov ebx, [rsi]
 mov [rdi], ebx
 mov [rsi], eax
 

其中rdi , rsi是两个 32 位整数的 memory 地址。 地址计算通常应该通过计算要跳过的步幅或偏移量来加速，以使第 N 个元素向右或向下。

汇编器中的整个矩阵转置可能最好由编译器生成。 OTOH 编译器可能无法使用 SIMD 指令，因为在将操作中断为 4x4 子矩阵块时：

for (y = 0; y < size/4; y++) {
    for (x = 0; x < y; x++) {
        if (y == x) {
            transposeSubBlock(matrix, y);
        } else if (y < x) {
            transposeSubBlock(matrix, y, x);
        }
    }
}

现在通过加载 4 个 SIMD 寄存器（从相邻的行和相邻的列）、转置寄存器并回写来在矩阵对角线上转置单个 4x4 块。

__m128i a[4];
a[0] = _mm_loadu_si128(row + 0 * stride);
a[1] = _mm_loadu_si128(row + 1 * stride);
a[2] = _mm_loadu_si128(row + 2 * stride);
a[3] = _mm_loadu_si128(row + 3 *stride);
transpose(a[0],a[1],a[2],a[3]);
_mm_storeu_si128(row + 0 * stride, a[0]);
_mm_storeu_si128(row + 1 * stride, a[1]);
_mm_storeu_si128(row + 2 * stride, a[2]);
_mm_storeu_si128(row + 3 * stride, a[3]);

其他块通过加载两个 4x4 块、在寄存器中转置两个块并写入相反的目标来处理。

__m128i a[4], b[4];
load4vectors(a, src0, stride);
load4vectors(b, src1, stride);
transpose(a[0],a[1],a[2],a[3]);
transpose(b[0],b[1],b[2],b[3]);
store4vectors(src0, b[0],b[1],b[2],b[3]);
store4vectors(src1, a[0],a[1],a[2],a[3]);

转置 int[4][4] 矩阵的一种可能方法是将每个元素转换为__m128 apply MM_TRANSPOSE_PS(a,b,c,d); 宏并将每个元素转换回__m128i 。

剩下的任务是处理多余的元素，这些元素不是 4 的倍数。