【问题标题】:Efficient 4x4 matrix multiplication (C vs assembly)高效的 4x4 矩阵乘法(C 与汇编)
【发布时间】:2013-09-01 05:44:20
【问题描述】:

我正在寻找一种在 C 语言中将两个 4x4 矩阵相乘的更快、更复杂的方法。我目前的研究主要集中在带有 SIMD 扩展的 x86-64 汇编上。到目前为止,我已经创建了一个函数,它比简单的 C 实现快了大约 6 倍,这超出了我对性能改进的预期。不幸的是,只有在没有优化标志用于编译(GCC 4.7)时,这才是正确的。使用-O2,C 变得更快,而我的努力变得毫无意义。

我知道现代编译器利用复杂的优化技术来实现几乎完美的代码,通常比巧妙的手工汇编要快。但在少数性能关键的情况下,人类可能会尝试与编译器争夺时钟周期。特别是当可以探索一些由现代 ISA 支持的数学时(就像我的情况一样)。

我的函数如下所示(AT&T 语法,GNU 汇编程序):

    .text
    .globl matrixMultiplyASM
    .type matrixMultiplyASM, @function
matrixMultiplyASM:
    movaps   (%rdi), %xmm0    # fetch the first matrix (use four registers)
    movaps 16(%rdi), %xmm1
    movaps 32(%rdi), %xmm2
    movaps 48(%rdi), %xmm3
    xorq %rcx, %rcx           # reset (forward) loop iterator
.ROW:
    movss (%rsi), %xmm4       # Compute four values (one row) in parallel:
    shufps $0x0, %xmm4, %xmm4 # 4x 4FP mul's, 3x 4FP add's 6x mov's per row,
    mulps %xmm0, %xmm4        # expressed in four sequences of 5 instructions,
    movaps %xmm4, %xmm5       # executed 4 times for 1 matrix multiplication.
    addq $0x4, %rsi

    movss (%rsi), %xmm4       # movss + shufps comprise _mm_set1_ps intrinsic
    shufps $0x0, %xmm4, %xmm4 #
    mulps %xmm1, %xmm4
    addps %xmm4, %xmm5
    addq $0x4, %rsi           # manual pointer arithmetic simplifies addressing

    movss (%rsi), %xmm4
    shufps $0x0, %xmm4, %xmm4
    mulps %xmm2, %xmm4        # actual computation happens here
    addps %xmm4, %xmm5        #
    addq $0x4, %rsi

    movss (%rsi), %xmm4       # one mulps operand fetched per sequence
    shufps $0x0, %xmm4, %xmm4 #  |
    mulps %xmm3, %xmm4        # the other is already waiting in %xmm[0-3]
    addps %xmm4, %xmm5
    addq $0x4, %rsi           # 5 preceding comments stride among the 4 blocks

    movaps %xmm5, (%rdx,%rcx) # store the resulting row, actually, a column
    addq $0x10, %rcx          # (matrices are stored in column-major order)
    cmpq $0x40, %rcx
    jne .ROW
    ret
.size matrixMultiplyASM, .-matrixMultiplyASM

它通过处理 128 位 SSE 寄存器中的四个浮点数来计算每次迭代的结果矩阵的一整列。完全矢量化可以通过一点数学(操作重新排序和聚合)和mullps/addps 指令来实现 4xfloat 包的并行乘法/加法。该代码重用了用于传递参数的寄存器(%rdi%rsi%rdx:GNU/Linux ABI),受益于(内部)循环展开并将一个矩阵完全保存在 XMM 寄存器中以减少内存读取。如您所见,我已经研究了该主题并花时间尽我所能实现它。

征服我的代码的天真的 C 计算如下所示:

void matrixMultiplyNormal(mat4_t *mat_a, mat4_t *mat_b, mat4_t *mat_r) {
    for (unsigned int i = 0; i < 16; i += 4)
        for (unsigned int j = 0; j < 4; ++j)
            mat_r->m[i + j] = (mat_b->m[i + 0] * mat_a->m[j +  0])
                            + (mat_b->m[i + 1] * mat_a->m[j +  4])
                            + (mat_b->m[i + 2] * mat_a->m[j +  8])
                            + (mat_b->m[i + 3] * mat_a->m[j + 12]);
}

我研究了上述 C 代码的优化汇编输出,它在 XMM 寄存器中存储浮点数时,不涉及任何并行操作——只是标量计算、指针算术和条件跳转。编译器的代码似乎不那么刻意,但它仍然比我的矢量化版本更有效,预计要快 4 倍。我确信一般的想法是正确的——程序员做类似的事情并获得有益的结果。但这里有什么问题?是否有任何我不知道的寄存器分配或指令调度问题?你知道任何 x86-64 组装工具或技巧来支持我与机器的战斗吗?

【问题讨论】:

  • 最近的编译器可以比人类更好地进行微优化。专注于算法优化!
  • 这正是我所做的——我使用了另一种计算来适应 SSE 的问题。它实际上是一种不同的算法。问题可能是,现在我还必须在指令级别对其进行优化,因为在专注于算法的同时,我可能引入了数据依赖性问题、无效的内存访问模式或其他一些黑魔法。
  • 您最好使用通过 &lt;immintrin.h&gt; 获得的 SSE 内在函数 - 您可以尝试其他方法,例如 _mm_dp_ps_MM_TRANSPOSE4_PS,而无需维护程序集。
  • 如果将restrict 限定符添加到C 函数的指针参数并使用-O3 进行编译,GCC 会将其向量化。如果没有 restrict 限定符,编译器必须假定输出矩阵可能与输入矩阵之一相同。
  • @BrettHale,我同意内在函数是这样做的方法,但 _mm_dp_ps_MM_TRANSPOSE4_PS 效率低下。查看我的回答和stackoverflow.com/questions/14967969/…

标签: c optimization assembly sse matrix-multiplication


【解决方案1】:

我想知道转置其中一个矩阵是否有益。

考虑我们如何将以下两个矩阵相乘...

A1 A2 A3 A4        W1 W2 W3 W4
B1 B2 B3 B4        X1 X2 X3 X4
C1 C2 C3 C4    *   Y1 Y2 Y3 Y4
D1 D2 D3 D4        Z1 Z2 Z3 Z4

这将导致...

dot(A,?1) dot(A,?2) dot(A,?3) dot(A,?4)
dot(B,?1) dot(B,?2) dot(B,?3) dot(B,?4)
dot(C,?1) dot(C,?2) dot(C,?3) dot(C,?4)
dot(D,?1) dot(D,?2) dot(D,?3) dot(D,?4)

行和列的点积很痛苦。

如果我们在相乘之前转置第二个矩阵会怎样?

A1 A2 A3 A4        W1 X1 Y1 Z1
B1 B2 B3 B4        W2 X2 Y2 Z2
C1 C2 C3 C4    *   W3 X3 Y3 Z3
D1 D2 D3 D4        W4 X4 Y4 Z4

现在我们正在做两行的点积,而不是行和列的点积。这有助于更好地使用 SIMD 指令。

希望这会有所帮助。

【讨论】:

  • 你几乎不想用 SSE 做两个向量的点积。相反,您确实一次做四个点积。您使用标量代码执行相同的操作,但您使用 SIMD 寄存器。例如。对于四个分量向量,这意味着您执行 4 个_mm_mul_ps 和 3 个_mm_add_ps,这给您四个点积。
  • @redrum:我明白了。到目前为止,我一直在将“mulps”和“haddps”组合用于点积和矩阵、向量乘法。看来我还有一些调整要做。
  • hadd 有时会用到,但在这种情况下不会。我从来没有发现dpps 有用。
  • @Zboson 你介意再解释一下你的陈述吗?如果一切都与标量情况相同,为什么要执行 4 个 _mm_mul_pss 而不是 _mm_mul_sss?
  • @user1095108,我从未将_mm_dp_ps_mm_hadd_ps 用于单点积。我会尝试重新组织我的代码,这样我就不必这样做了。阅读此cdl.uni-saarland.de/papers/leissa_vecimp_tr.pdf。但英特尔创建_mm_dp_ps 肯定是有原因的。不久前,我读到了他们关于此的说明。如果您不能更改代码并且必须一次计算一个点积,那么_mm_dp_ps 可能有一些好处,但据我记得这是一个小的改进,并且没有任何接近 4 的因素,您可以从做 4立刻。您可以编写代码来测试它。
【解决方案2】:

4x4 矩阵乘法是 64 次乘法和 48 次加法。使用 SSE,这可以减少到 16 次乘法和 12 次加法(以及 16 次广播)。以下代码将为您执行此操作。它只需要 SSE (#include &lt;xmmintrin.h&gt;)。数组 ABC 需要 16 字节对齐。使用水平指令如hadd (SSE3) 和dpps (SSE4.1) 将是less efficient(尤其是dpps)。我不知道循环展开是否会有所帮助。

void M4x4_SSE(float *A, float *B, float *C) {
    __m128 row1 = _mm_load_ps(&B[0]);
    __m128 row2 = _mm_load_ps(&B[4]);
    __m128 row3 = _mm_load_ps(&B[8]);
    __m128 row4 = _mm_load_ps(&B[12]);
    for(int i=0; i<4; i++) {
        __m128 brod1 = _mm_set1_ps(A[4*i + 0]);
        __m128 brod2 = _mm_set1_ps(A[4*i + 1]);
        __m128 brod3 = _mm_set1_ps(A[4*i + 2]);
        __m128 brod4 = _mm_set1_ps(A[4*i + 3]);
        __m128 row = _mm_add_ps(
                    _mm_add_ps(
                        _mm_mul_ps(brod1, row1),
                        _mm_mul_ps(brod2, row2)),
                    _mm_add_ps(
                        _mm_mul_ps(brod3, row3),
                        _mm_mul_ps(brod4, row4)));
        _mm_store_ps(&C[4*i], row);
    }
}

【讨论】:

  • 非常感谢您的回答。该代码看起来比我之前使用 SSE 内在函数进行矩阵乘法的实验更好。它还使用-O2 提供了一个更好看的组件,并且运行速度比我的快一点。但我仍然想知道为什么我不能通过纯组装获得至少相同的结果。
  • 如果您使用的是 GCC,为什么不使用 -O3 进行编译?
  • 可能是因为我一直被告知-O3 引入了激进的优化技术,这可能不会提高性能,但可能会带来额外的成本,例如通过在展开循环或内联函数时增加代码大小。但你是对的——首先是-O3,然后是低级优化! :-) 幸运的是,在我的示例中并没有太大区别。
【解决方案3】:

有一种方法可以加速代码并超越编译器。它不涉及任何复杂的管道分析或深度代码微优化(这并不意味着它不能进一步受益于这些)。优化使用了三个简单的技巧:

  1. 该函数现在是 32 字节对齐的(显着提高了性能),

  2. 主循环反向运行,这减少了与零测试的比较(基于 EFLAGS),

  3. 指令级地址运算被证明比“外部”指针计算更快(尽管它需要两倍的加法«在 3/4 情况下»)。它将循环体缩短了四条指令,并减少了其执行路径中的数据依赖性。 See related question.

此外,代码使用相对跳转语法来抑制符号重定义错误,这种错误发生在 GCC 尝试内联它时(在放置在 asm 语句中并使用 -O3 编译之后)。

    .text
    .align 32                           # 1. function entry alignment
    .globl matrixMultiplyASM            #    (for a faster call)
    .type matrixMultiplyASM, @function
matrixMultiplyASM:
    movaps   (%rdi), %xmm0
    movaps 16(%rdi), %xmm1
    movaps 32(%rdi), %xmm2
    movaps 48(%rdi), %xmm3
    movq $48, %rcx                      # 2. loop reversal
1:                                      #    (for simpler exit condition)
    movss (%rsi, %rcx), %xmm4           # 3. extended address operands
    shufps $0, %xmm4, %xmm4             #    (faster than pointer calculation)
    mulps %xmm0, %xmm4
    movaps %xmm4, %xmm5
    movss 4(%rsi, %rcx), %xmm4
    shufps $0, %xmm4, %xmm4
    mulps %xmm1, %xmm4
    addps %xmm4, %xmm5
    movss 8(%rsi, %rcx), %xmm4
    shufps $0, %xmm4, %xmm4
    mulps %xmm2, %xmm4
    addps %xmm4, %xmm5
    movss 12(%rsi, %rcx), %xmm4
    shufps $0, %xmm4, %xmm4
    mulps %xmm3, %xmm4
    addps %xmm4, %xmm5
    movaps %xmm5, (%rdx, %rcx)
    subq $16, %rcx                      # one 'sub' (vs 'add' & 'cmp')
    jge 1b                              # SF=OF, idiom: jump if positive
    ret

这是迄今为止我见过的最快的 x86-64 实现。我将不胜感激,投票并接受任何为此目的提供更快组装的答案!

【讨论】:

  • 我无法让它工作。我用这个签名从 C 调用它: void abramowicz_MM4x4(float *A, float *B, float *C);然后我将程序集放在另一个名为匹配 gcc 名称修饰的文件中:.globl _Z16abramowicz_MM4x4PfS_S _Z16abramowicz_MM4x4PfS_S:调用给出了不正确的值。可能出了什么问题?
  • 问题是参数的顺序被颠倒了。对于任何打算尝试此操作的人,要么在 C 中的函数签名中翻转 A 和 B,要么在 asm 中翻转 rdi 和 rsi。
  • 谁有上面的英特尔 ASM 翻译?
  • 我在here 的主题上写了一篇扩展的博客文章。我还将程序集版本翻译成 Visual Studio 可用的东西,尽管对我的版本进行了一些小改动以保持二进制精确。不过我的非汇编版本要快一点!
【解决方案4】:

显然,您可以一次从四个矩阵中获取项,并使用相同的算法同时将四个矩阵相乘。

【讨论】:

  • 细化...它真的回答了这个问题吗?
  • 我不认为从四个不同的输入矩阵中收集元素然后分散回四个不同的结果矩阵会比使用加载+广播(就像 OP 自己的答案那样)更快。跨度>
【解决方案5】:

Sandy Bridge 扩展了上述指令集以支持 8 元素向量算术。考虑一下这个实现。

struct MATRIX {
    union {
        float  f[4][4];
        __m128 m[4];
        __m256 n[2];
    };
};
MATRIX myMultiply(MATRIX M1, MATRIX M2) {
    // Perform a 4x4 matrix multiply by a 4x4 matrix 
    // Be sure to run in 64 bit mode and set right flags
    // Properties, C/C++, Enable Enhanced Instruction, /arch:AVX 
    // Having MATRIX on a 32 byte bundry does help performance
    MATRIX mResult;
    __m256 a0, a1, b0, b1;
    __m256 c0, c1, c2, c3, c4, c5, c6, c7;
    __m256 t0, t1, u0, u1;

    t0 = M1.n[0];                                                   // t0 = a00, a01, a02, a03, a10, a11, a12, a13
    t1 = M1.n[1];                                                   // t1 = a20, a21, a22, a23, a30, a31, a32, a33
    u0 = M2.n[0];                                                   // u0 = b00, b01, b02, b03, b10, b11, b12, b13
    u1 = M2.n[1];                                                   // u1 = b20, b21, b22, b23, b30, b31, b32, b33

    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(0, 0, 0, 0));        // a0 = a00, a00, a00, a00, a10, a10, a10, a10
    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(0, 0, 0, 0));        // a1 = a20, a20, a20, a20, a30, a30, a30, a30
    b0 = _mm256_permute2f128_ps(u0, u0, 0x00);                      // b0 = b00, b01, b02, b03, b00, b01, b02, b03  
    c0 = _mm256_mul_ps(a0, b0);                                     // c0 = a00*b00  a00*b01  a00*b02  a00*b03  a10*b00  a10*b01  a10*b02  a10*b03
    c1 = _mm256_mul_ps(a1, b0);                                     // c1 = a20*b00  a20*b01  a20*b02  a20*b03  a30*b00  a30*b01  a30*b02  a30*b03

    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(1, 1, 1, 1));        // a0 = a01, a01, a01, a01, a11, a11, a11, a11
    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(1, 1, 1, 1));        // a1 = a21, a21, a21, a21, a31, a31, a31, a31
    b0 = _mm256_permute2f128_ps(u0, u0, 0x11);                      // b0 = b10, b11, b12, b13, b10, b11, b12, b13
    c2 = _mm256_mul_ps(a0, b0);                                     // c2 = a01*b10  a01*b11  a01*b12  a01*b13  a11*b10  a11*b11  a11*b12  a11*b13
    c3 = _mm256_mul_ps(a1, b0);                                     // c3 = a21*b10  a21*b11  a21*b12  a21*b13  a31*b10  a31*b11  a31*b12  a31*b13

    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(2, 2, 2, 2));        // a0 = a02, a02, a02, a02, a12, a12, a12, a12
    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(2, 2, 2, 2));        // a1 = a22, a22, a22, a22, a32, a32, a32, a32
    b1 = _mm256_permute2f128_ps(u1, u1, 0x00);                      // b0 = b20, b21, b22, b23, b20, b21, b22, b23
    c4 = _mm256_mul_ps(a0, b1);                                     // c4 = a02*b20  a02*b21  a02*b22  a02*b23  a12*b20  a12*b21  a12*b22  a12*b23
    c5 = _mm256_mul_ps(a1, b1);                                     // c5 = a22*b20  a22*b21  a22*b22  a22*b23  a32*b20  a32*b21  a32*b22  a32*b23

    a0 = _mm256_shuffle_ps(t0, t0, _MM_SHUFFLE(3, 3, 3, 3));        // a0 = a03, a03, a03, a03, a13, a13, a13, a13
    a1 = _mm256_shuffle_ps(t1, t1, _MM_SHUFFLE(3, 3, 3, 3));        // a1 = a23, a23, a23, a23, a33, a33, a33, a33
    b1 = _mm256_permute2f128_ps(u1, u1, 0x11);                      // b0 = b30, b31, b32, b33, b30, b31, b32, b33
    c6 = _mm256_mul_ps(a0, b1);                                     // c6 = a03*b30  a03*b31  a03*b32  a03*b33  a13*b30  a13*b31  a13*b32  a13*b33
    c7 = _mm256_mul_ps(a1, b1);                                     // c7 = a23*b30  a23*b31  a23*b32  a23*b33  a33*b30  a33*b31  a33*b32  a33*b33

    c0 = _mm256_add_ps(c0, c2);                                     // c0 = c0 + c2 (two terms, first two rows)
    c4 = _mm256_add_ps(c4, c6);                                     // c4 = c4 + c6 (the other two terms, first two rows)
    c1 = _mm256_add_ps(c1, c3);                                     // c1 = c1 + c3 (two terms, second two rows)
    c5 = _mm256_add_ps(c5, c7);                                     // c5 = c5 + c7 (the other two terms, second two rose)

                                                                    // Finally complete addition of all four terms and return the results
    mResult.n[0] = _mm256_add_ps(c0, c4);       // n0 = a00*b00+a01*b10+a02*b20+a03*b30  a00*b01+a01*b11+a02*b21+a03*b31  a00*b02+a01*b12+a02*b22+a03*b32  a00*b03+a01*b13+a02*b23+a03*b33
                                                //      a10*b00+a11*b10+a12*b20+a13*b30  a10*b01+a11*b11+a12*b21+a13*b31  a10*b02+a11*b12+a12*b22+a13*b32  a10*b03+a11*b13+a12*b23+a13*b33
    mResult.n[1] = _mm256_add_ps(c1, c5);       // n1 = a20*b00+a21*b10+a22*b20+a23*b30  a20*b01+a21*b11+a22*b21+a23*b31  a20*b02+a21*b12+a22*b22+a23*b32  a20*b03+a21*b13+a22*b23+a23*b33
                                                //      a30*b00+a31*b10+a32*b20+a33*b30  a30*b01+a31*b11+a32*b21+a33*b31  a30*b02+a31*b12+a32*b22+a33*b32  a30*b03+a31*b13+a32*b23+a33*b33
    return mResult;
}

【讨论】:

  • .xmm[].ymm[] 可能是更好的工会成员名称。除此之外,看起来不错。不过,相当多的洗牌。可能值得存储到内存中,以便您可以广播加载。 (除非编译器将其“优化”回随机播放...)
  • 在 Haswell 及更高版本上,vbroadcastss ymm, [mem] 是加载端口中的单个微指令。在 SnB/IvB 上,它是负载 + 端口 5 洗牌。但这仍然胜过 vshufps + vperm2f128 的 2 个 port5 shuffle。 (或 vinsertf128。)
  • 哦 NVM,您正在执行两个单独的通道内广播,而 permute2f128 在另一个操作数上。是的,看起来不错。使用-march=haswell,4 个 mul/add 对折叠成 FMA:godbolt.org/g/9uEbhR。嗯,那些_mm256_permute2f128_ps(same,same, 0) 是广播,但编译器不会把它们变成vinsertf128。在这里,您可以为 Haswell 保存具有广播 128 负载的 shuffle-port 微指令。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2013-07-21
  • 1970-01-01
  • 1970-01-01
  • 2015-07-26
  • 2013-10-21
  • 2014-02-25
  • 1970-01-01
相关资源
最近更新 更多