Есть ли способ оптимизировать умножение матриц в C?

Question

Мой код выглядит следующим образом, и в основной функции я вспоминаю Mat_product функцию около 223440 раз, используйте 179ns, 23% во всем времени выполнения.

struct Matrix_SE3 {
    float R[3][3];
    double P[3];  //here i need use double type.
};

struct Matrix_SE3 Mat_product(struct Matrix_SE3 A, struct Matrix_SE3 B) {
    struct Matrix_SE3 result = { { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }, { 0,
            0, 0 } };
    for (int i = 0; i < 3; i++) {
        result.P[i] += A.P[i];
        for (int j = 0; j < 3; j++) {
            result.P[i] += A.R[i][j] * B.P[j];
            for (int k = 0; k < 3; k++)
                result.R[i][j] += A.R[i][k] * B.R[k][j];
        }
    }
    return result;
}

где $ R $ - матрица вращения, а $ P $ - позиция, функция рассчитывается при умножении двух специальных евклидовых групп на матрицу $ SE (3) $ и возвращает матрицу $ SE (3) $.

Может быть, это дубликат Оптимизированное матричное умножение в C , разница в том, что мой код использует struct для описания матрицы, влияет ли это на эффективность вычислений?

Answer 1

Не уверен, что P и R равны в вашем коде, но вы никогда не должны использовать порядок ijk для умножения матриц.

Из-за упорядочения основной строки при доступе к B.R [k] [j] во внутреннем цикле многие обращения приводят к пропаданию кэша, что значительно снижает производительность даже при небольших матрицах.

Надлежащим способом умножения матриц является итерация в порядке ikj.

for (int i = 0; i < 3; i++) {
    double r;
    result.P[i] += A.P[i];
    for (int k = 0; k < 3; k++) {
        r=A.R[i][k];
        for (int j = 0; j < 3; j++) {
            result.P[i] += A.R[i][j] * B.P[j];  
            result.R[i][j] += r * B.R[k][j];
        }
    }
}

Все обращения будут выполняться правильно в порядке следования строк и будут выигрывать от поведения кэша.

И не забудьте использовать оптимизацию -O3. Большинство компиляторов будут использовать инструкции sse / avx для оптимизации кода.