矩阵相乘_重排序优化算法的C++实现

都知道计算机执行矩阵相乘运算很麻烦,使用传统数学算法的时间复杂度是O(n^3)。

这里不讨论数学上的优化算法。在计算机计算时有个cache-miss问题,这里讨论一下。

C++里的矩阵,其实是二维数组。在存储的时候是按行存的,cache在读取的时候,也是按行取的(下面的代码可以证明)。如果按照正常算法执行矩阵相乘,依次计算新矩阵每个位置的结果,用第一个矩阵的行去乘第二个矩阵的列,然后累加求和,那第二个矩阵每次运算都跨行了,这涉及到3层循环,第1层表示行,第2层表示列,第3层表示累加。那第3层循环里,每次都会有cache-miss。

如果能设计一个算法,让第3层循环的不要跨行,而是一直在执行某一行的计算,该行的所有元素都取完了再去执行下一行,那就可以避免cache-miss了。

这里给出3组方法,第1种是原始的方法。第2和第3种方法调整了循环顺序。

第二个方法是重排序V1版本,第三种方法是重排序的V2版本。

2个版本的区别是:最内层循环的读取矩阵的顺序,V1是逐行读取,V2是逐列读取。

cpp 复制代码
#include <iostream>
#include <vector>
#include <chrono>

using namespace std;

void matrixMultiplyReorderedV2(const vector<vector<int>>& A, const vector<vector<int>>& B, vector<vector<int>>& C) {
    int m = A.size();
    int n = B.size();
    int p = B[0].size();
    
    for (int k = 0; k < n; k++) {
        for (int j = 0; j < p; j++) {
            for (int i = 0; i < m; i++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

void matrixMultiplyReorderedV1(const vector<vector<int>>& A, const vector<vector<int>>& B, vector<vector<int>>& C) {
    int m = A.size();
    int n = B.size();
    int p = B[0].size();
    
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < p; j++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

void clearVecC(std::vector< vector<int> >& C)
{
    for (int i = 0; i < C.size(); i++) {
        for (int j = 0; j < C[0].size(); j++) {
            C[i][j] = 0;
        }
    }
}

void matrixMultiplyOriginal(const vector<vector<int>>& A, const vector<vector<int>>& B, vector<vector<int>>& C) {
    int m = A.size();
    int n = B.size();
    int p = B[0].size();
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < p; j++) {
            for (int k = 0; k < n; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

int main() {
    int sz = 1000;
    int m = sz, n = sz, p = sz; // 矩阵大小
    vector<vector<int>> A(m, vector<int>(n, 1));
    vector<vector<int>> B(n, vector<int>(p, 1));
    vector<vector<int>> C(m, vector<int>(p, 0));

    auto start = chrono::high_resolution_clock::now();
    matrixMultiplyOriginal(A, B, C);
    auto end = chrono::high_resolution_clock::now();

    chrono::duration<double> duration = end - start;
    cout << "Original version time: " << duration.count() << " seconds" << endl;

    clearVecC(C);
    start = chrono::high_resolution_clock::now();
    matrixMultiplyReorderedV1(A, B, C);
    end = chrono::high_resolution_clock::now();

    duration = end - start;
    cout << "matrixMultiplyReorderedV1 version time: " << duration.count() << " seconds" << endl;

    clearVecC(C);
    start = chrono::high_resolution_clock::now();
    matrixMultiplyReorderedV2(A, B, C);
    end = chrono::high_resolution_clock::now();


    duration = end - start;
    cout << "matrixMultiplyReorderedV1 version time: " << duration.count() << " seconds" << endl;

    return 0;
}

运行结果是:

bash 复制代码
Original version time: 22.9585 seconds
matrixMultiplyReorderedV1 version time: 12.499 seconds
matrixMultiplyReorderedV1 version time: 25.3616 seconds

可以看到,V1版本明显缩短了运算时间,减少了cache-miss。V2版本没效果,反而比原始版本的还差一点。这可以说明:cache是按行读取内存的矩阵的,而不是列。

另外,使用多线程可以缩短计算时间,我在另一篇文章(多线程实现矩阵相乘_C++)里有详细说明。

相关推荐
LaoZhangGong12317 分钟前
使用常数指针作为函数参数
c++·经验分享
边疆.18 分钟前
C++类和对象 (中)
c语言·开发语言·c++·算法
binqian30 分钟前
【K8S】kubernetes-dashboard.yaml
算法·贪心算法
Wils0nEdwards1 小时前
Leetcode 合并 K 个升序链表
算法·leetcode·链表
Tisfy1 小时前
LeetCode 3211.生成不含相邻零的二进制字符串:二进制枚举+位运算优化
算法·leetcode·二进制·题解·枚举·位运算
好看资源平台1 小时前
深入理解所有权与借用——借用与生命周期管理
开发语言·算法·rust
qiaoxinyu19891 小时前
线性代数(1)——线性方程组的几何意义
线性代数·算法·机器学习
爱吃饭团的饭桶2 小时前
【附源码】Python :哈密顿回路
开发语言·python·算法
TNTLWT2 小时前
算法:查找
算法
feilieren2 小时前
leetcode - 684. 冗余连接
java·开发语言·算法