C++ 如何优化4x4矩阵乘法？

我目前正在开发一个跨平台图形引擎，性能分析表明我应该优化matrixmultiplication

Y检查矩阵是否有修改，因此如果没有更改，我不会更新矩阵，但无论如何，世界矩阵乘法使用了大量的处理百分比

<> P>有没有一种方法能更快地使用C++语言技巧？

GRPMATRIX* GRPMATRIX::GetMulplicationMatrix(GRPMATRIX* a, GRPMATRIX* b)
{           
matrix[0][0] = a->matrix[0][0]*b->matrix[0][0]+a->matrix[1][0]*b->matrix[0][1]+a->matrix[2][0]*b->matrix[0][2]+a->matrix[3][0]*b->matrix[0][3];

matrix[0][1] = a->matrix[0][1]*b->matrix[0][0]+a->matrix[1][1]*b->matrix[0][1]+a->matrix[2][1]*b->matrix[0][2]+a->matrix[3][1]*b->matrix[0][3];
matrix[0][2] = a->matrix[0][2]*b->matrix[0][0]+a->matrix[1][2]*b->matrix[0][1]+a->matrix[2][2]*b->matrix[0][2]+a->matrix[3][2]*b->matrix[0][3];
matrix[0][3] = a->matrix[0][3]*b->matrix[0][0]+a->matrix[1][3]*b->matrix[0][1]+a->matrix[2][3]*b->matrix[0][2]+a->matrix[3][3]*b->matrix[0][3];

matrix[1][0] = a->matrix[0][0]*b->matrix[1][0]+a->matrix[1][0]*b->matrix[1][1]+a->matrix[2][0]*b->matrix[1][2]+a->matrix[3][0]*b->matrix[1][3];
matrix[1][1] = a->matrix[0][1]*b->matrix[1][0]+a->matrix[1][1]*b->matrix[1][1]+a->matrix[2][1]*b->matrix[1][2]+a->matrix[3][1]*b->matrix[1][3];
matrix[1][2] = a->matrix[0][2]*b->matrix[1][0]+a->matrix[1][2]*b->matrix[1][1]+a->matrix[2][2]*b->matrix[1][2]+a->matrix[3][2]*b->matrix[1][3];
matrix[1][3] = a->matrix[0][3]*b->matrix[1][0]+a->matrix[1][3]*b->matrix[1][1]+a->matrix[2][3]*b->matrix[1][2]+a->matrix[3][3]*b->matrix[1][3];

matrix[2][0] = a->matrix[0][0]*b->matrix[2][0]+a->matrix[1][0]*b->matrix[2][1]+a->matrix[2][0]*b->matrix[2][2]+a->matrix[3][0]*b->matrix[2][3];
matrix[2][1] = a->matrix[0][1]*b->matrix[2][0]+a->matrix[1][1]*b->matrix[2][1]+a->matrix[2][1]*b->matrix[2][2]+a->matrix[3][1]*b->matrix[2][3];
matrix[2][2] = a->matrix[0][2]*b->matrix[2][0]+a->matrix[1][2]*b->matrix[2][1]+a->matrix[2][2]*b->matrix[2][2]+a->matrix[3][2]*b->matrix[2][3];
matrix[2][3] = a->matrix[0][3]*b->matrix[2][0]+a->matrix[1][3]*b->matrix[2][1]+a->matrix[2][3]*b->matrix[2][2]+a->matrix[3][3]*b->matrix[2][3];

matrix[3][0] = a->matrix[0][0]*b->matrix[3][0]+a->matrix[1][0]*b->matrix[3][1]+a->matrix[2][0]*b->matrix[3][2]+a->matrix[3][0]*b->matrix[3][3];
matrix[3][1] = a->matrix[0][1]*b->matrix[3][0]+a->matrix[1][1]*b->matrix[3][1]+a->matrix[2][1]*b->matrix[3][2]+a->matrix[3][1]*b->matrix[3][3];
matrix[3][2] = a->matrix[0][2]*b->matrix[3][0]+a->matrix[1][2]*b->matrix[3][1]+a->matrix[2][2]*b->matrix[3][2]+a->matrix[3][2]*b->matrix[3][3];
matrix[3][3] = a->matrix[0][3]*b->matrix[3][0]+a->matrix[1][3]*b->matrix[3][1]+a->matrix[2][3]*b->matrix[3][2]+a->matrix[3][3]*b->matrix[3][3];

return this;
}

我不做任何检查，如果有的话也不做，但我不知道是否有办法提高性能，或者是否存在死胡同

对于任何正在寻找类似内容的人，在使用gnasher answer后，代码如下所示：

    float a00=a->matrix[0][0];
float a01=a->matrix[0][1];
float a02=a->matrix[0][2];
float a03=a->matrix[0][3];

float a10=a->matrix[1][0];
float a11=a->matrix[1][1];
float a12=a->matrix[1][2];
float a13=a->matrix[1][3];

float a20=a->matrix[2][0];
float a21=a->matrix[2][1];
float a22=a->matrix[2][2];
float a23=a->matrix[2][3];

float a30=a->matrix[3][0];
float a31=a->matrix[3][1];
float a32=a->matrix[3][2];
float a33=a->matrix[3][3];

float b00=b->matrix[0][0];
float b01=b->matrix[0][1];
float b02=b->matrix[0][2];
float b03=b->matrix[0][3];

float b10=b->matrix[1][0];
float b11=b->matrix[1][1];
float b12=b->matrix[1][2];
float b13=b->matrix[1][3];

float b20=b->matrix[2][0];
float b21=b->matrix[2][1];
float b22=b->matrix[2][2];
float b23=b->matrix[2][3];

float b30=b->matrix[3][0];
float b31=b->matrix[3][1];
float b32=b->matrix[3][2];
float b33=b->matrix[3][3];

matrix[0][0] = a00*b00+a10*b01+a20*b02+a30*b03;
matrix[0][1] = a01*b00+a11*b01+a21*b02+a31*b03;
matrix[0][2] = a02*b00+a12*b01+a22*b02+a32*b03;
matrix[0][3] = a03*b00+a13*b01+a23*b02+a33*b03;

matrix[1][0] = a00*b10+a10*b11+a20*b12+a30*b13;
matrix[1][1] = a01*b10+a11*b11+a21*b12+a31*b13;
matrix[1][2] = a02*b10+a12*b11+a22*b12+a32*b13;
matrix[1][3] = a03*b10+a13*b11+a23*b12+a33*b13;

matrix[2][0] = a00*b20+a10*b21+a20*b22+a30*b23;
matrix[2][1] = a01*b20+a11*b21+a21*b22+a31*b23;
matrix[2][2] = a02*b20+a12*b21+a22*b22+a32*b23;
matrix[2][3] = a03*b20+a13*b21+a23*b22+a33*b23;

matrix[3][0] = a00*b30+a10*b31+a20*b32+a30*b33;
matrix[3][1] = a01*b30+a11*b31+a21*b32+a31*b33;
matrix[3][2] = a02*b30+a12*b31+a22*b32+a32*b33;
matrix[3][3] = a03*b30+a13*b31+a23*b32+a33*b33;

---

您遇到的一个问题是，在任何赋值矩阵[i][j]=…，编译器都不知道a和b没有指向这个->矩阵，因此它必须假设a和b的元素被覆盖，需要再次读取它们

如果你只是写作，你应该会有所进步

b0=b->矩阵[0][0]；b1=b->矩阵[0][1]。。。 矩阵[0][0]=

b0=b->矩阵[1][0]；b1=b->矩阵[1][1]。。。 矩阵[1][0]=

等等

---

阅读Peter的评论：如果这些矩阵实际上是指向双精度数组的指针数组，那绝对是性能杀手。不要这样做

要加快速度，请使用SSE2/AVX或其他SIMD解决方案。。。如果你需要进行大量的乘法运算，那么多线程也会有帮助。我需要跨平台（pc、android、rpi）进行乘法运算。不过无论如何，谢谢你，你的性能分析是什么？花在乘以4x4矩阵上的时间占多大百分比？我之所以这么问，是因为有时人们被告知他们的“热点”占用了10%的时间，而其他地方很容易有一个沉睡的巨人没有告诉他们。我假设这些矩阵是

双矩阵[4][4]

，而不是一个“锯齿矩阵”，比如

双**矩阵

，每行都有单独的分配？你是对的。事实上，我只需要在例程中有一个本地4x4矩阵，并在退出之前将其复制出来。太好了！这样做可以提高40%！我在348毫秒内完成了4000000次MULT，现在是209毫秒：不，它们不是数组，是纯浮点m[4][4]。如果我使用double而不是float，是否会有所改进？@diego.martinez测试它。