以矩阵乘法为例比较串行和各并行算法运行效率

最新推荐文章于 2022-12-26 16:15:50 发布
最新推荐文章于 2022-12-26 16:15:50 发布
阅读量6.6k 收藏 60
点赞数 12
分类专栏： 并行与分布式程序设计 文章标签： 并行计算 SIMD编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vincent_nkcs/article/details/89461380
版权
1 问题描述

  本次实验分别使用串行算法、Cache优化算法、SSE编程和分片策略算法实现了矩阵乘法运算，实验采用同一个样本，即矩阵大小为512个元素，元素值为由时间生成的随机数，每个算法对此样本运行十次，并记录每次运行时间和十次运算的平均运行时间。实验环境：计算机apple macbook pro2015、系统macOS High Sierra10.13.5、编辑器vscode&C/C++ Extension、gcc编译。

2 算法设计与实现

  首先在矩阵样本设计方面，考虑大越大规模的数据越能体现不同算法在运行上的差距，因而将矩阵大小设置为512个元素，并且为了减少元素数据对实验的影响，采取了随机数赋值的方法。

 srand((unsigned)time(NULL));
 float a[maxN][maxN];
 float b[maxN][maxN];
 for(int i = 0; i < n; i++)
 {
   for(int j=0; j < n; j++){
     a[i][j] = rand();
     b[i][j] = rand();
   }
 }

​ 其次考虑每个算法的具体实现：

2.1 串行算法

​ 由于矩阵乘法规则为乘积AB的第i个分量等于矩阵A的第i个行向量与列向量B的对应分量乘积之和，因而对矩阵A的每一行的元素，矩阵B的每一列的元素都要与之相乘并相加，所以需要先遍历矩阵A一行中的元素的同时遍历矩阵B一列中的元素，再遍历矩阵B中的每一列，再遍历矩阵A中的每一行，三层遍历嵌套，时间复杂度O(n) = n^3，用clock_t记录时间。

​ 具体代码如下：

double mul(int n,float a[][maxN],float b[][maxN],float c[][maxN]){ //串行算法 O(n) = n^3
    double time;
    clock_t start,end;
    start = clock();

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            c[i][j]= 0.0;
            for(int k = 0; k < n; k++){
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }

    end = clock();
    time = (double)(end-start);
    cout<<"串行算法耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}
2.2 Cache优化

​ 由于寄存器从内存中取值时，需要从内存中寻址，上述串行算法b[k][j]需要先对矩阵B的行进行遍历，又因为在c++中，二维数组相邻的元素地址相近，因而先对行进行遍历造成了地址跳跃，需要更长的寻址时间。将矩阵B转置，就能够实现对连续的地址进行读写操作，节省大量寻址时间。算法时间复杂度O(n) = n^3。

​ 具体代码如下：

double trans_mul(int n, float a[][maxN], float b[][maxN], float c[][maxN]){ // Cache优化 O(n) = n^3
    double time;
    clock_t start,end;
    start = clock();

    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]); 
    for (int i = 0; i < n; ++i) {  
        for (int j = 0; j < n; ++j) { 
            c[i][j] = 0.0;
            for (int k = 0; k < n; ++k) { 
                c[i][j] += a[i][k] * b[j][k];
                }
            }
    } // transposition
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]);

    end = clock();
    time = (double)(end-start);
    cout<<"Cache优化耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}
2.3 SSE版本

​ 基于SIMD编程，将多个元素同时进行寄存器加载和存储器存值等操作能够提高并行效率。使用SSE指令能够实现该功能。时间复杂度为O(n) = (n^3)/4，同样对矩阵B进行转置。

​ 具体代码如下：

double sse_mul(int n, float a[][maxN], float b[][maxN], float c[][maxN]){ //SSE版本 O(n) = (n^3)/4
    double time;
    clock_t start,end;
    start = clock();

    __m128 t1, t2, sum;  //__m128 == float
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]); 
    for (int i = 0; i < n; ++i){ 
        for (int j = 0; j < n; ++j){ 
            c[i][j] = 0.0;
            sum = _mm_setzero_ps();  //Initialize
            for (int k = n - 4; k >= 0; k -= 4){ // sum every 4 elements 
                t1 = _mm_loadu_ps(a[i] + k); 
                t2 = _mm_loadu_ps(b[j] + k); 
                t1 = _mm_mul_ps(t1, t2);
                sum = _mm_add_ps(sum, t1);
            }
            sum = _mm_hadd_ps(sum, sum); 
            sum = _mm_hadd_ps(sum, sum); 
            _mm_store_ss(c[i] + j, sum);
            for (int k = (n % 4) - 1; k >= 0; --k){ // handle the last n%4elements
                c[i][j] += a[i][k] * b[j][k];
            }
        }
    } 
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]);

    end = clock();
    time = (double)(end-start);
    cout<<"SSE版本耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}

​ 其中_mm_loadu_ps为同时加载四个单精度浮点数值的指令，因而循环每次跳跃四个元素，再将四个元素的乘积相加。对于矩阵n不能被4整除的情况，对剩余元素做类似Cache优化算法的操作。

2.4 分片策略

​ 先针对cpu线程数设置分片数，将矩阵分为多个小矩阵，对每个小矩阵进行SSE指令计算。时间复杂度为O(n) = n^3，同样对矩阵B进行转置。

​ 具体代码如下：

double sse_tile(int n, float a[][maxN], float b[][maxN], float c[][maxN]){ //分片策略  O(n) = n^3
    double time;
    clock_t start,end;
    start = clock();

    __m128 t1, t2, sum;
    float t;
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]); 
    for (int r = 0; r < n / T; ++r) 
        for (int q = 0; q < n / T; ++q) { 
            for (int i = 0; i < T; ++i) 
                for (int j = 0; j < T; ++j) 
                    c[r * T + i][q * T +j] = 0.0;
            for (int p = 0; p < n / T; ++p) { 
                for (int i = 0; i < T; ++i) 
                    for (int j = 0; j < T; ++j) { 
                        sum = _mm_setzero_ps();
                        for (int k = 0; k < T; k += 4){ //sum every 4th elements
                            t1 = _mm_loadu_ps(a[r * T + i] + p * T + k); 
                            t2 = _mm_loadu_ps(b[q * T + j] + p * T + k);
                            t1 = _mm_mul_ps(t1, t2); 
                            sum = _mm_add_ps(sum, t1);
                        }
                        sum = _mm_hadd_ps(sum, sum); 
                        sum = _mm_hadd_ps(sum, sum); 
                        _mm_store_ss(&t, sum);
                        c[r * T + i][q * T + j] += t;
                    }
            }
        } 
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]);

    end = clock();
    time = (double)(end-start);
    cout<<"分片策略耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}
3 实验结果及结果分析

​ 每个算法的十次运行时间结果如下：

第1次运行结果:
串行算法耗时: 0.753588s
Cache优化耗时: 0.453238s
SSE版本耗时: 0.230628s
分片策略耗时: 0.279179s

第2次运行结果:
串行算法耗时: 0.77117s
Cache优化耗时: 0.465396s
SSE版本耗时: 0.239504s
分片策略耗时: 0.293299s

第3次运行结果:
串行算法耗时: 0.746869s
Cache优化耗时: 0.451797s
SSE版本耗时: 0.228981s
分片策略耗时: 0.282906s

第4次运行结果:
串行算法耗时: 0.696163s
Cache优化耗时: 0.453274s
SSE版本耗时: 0.233736s
分片策略耗时: 0.277309s

第5次运行结果:
串行算法耗时: 0.878417s
Cache优化耗时: 0.490044s
SSE版本耗时: 0.271495s
分片策略耗时: 0.378412s

第6次运行结果:
串行算法耗时: 1.08664s
Cache优化耗时: 0.491328s
SSE版本耗时: 0.243387s
分片策略耗时: 0.291609s

第7次运行结果:
串行算法耗时: 0.777393s
Cache优化耗时: 0.470352s
SSE版本耗时: 0.233467s
分片策略耗时: 0.285942s

第8次运行结果:
串行算法耗时: 0.689719s
Cache优化耗时: 0.450596s
SSE版本耗时: 0.224129s
分片策略耗时: 0.284757s

第9次运行结果:
串行算法耗时: 0.692528s
Cache优化耗时: 0.450607s
SSE版本耗时: 0.229762s
分片策略耗时: 0.282219s

第10次运行结果:
串行算法耗时: 0.708097s
Cache优化耗时: 0.45446s
SSE版本耗时: 0.223255s
分片策略耗时: 0.28649s

平均耗时:
串行算法耗时:0.780058s
Cache优化耗时:0.463109s
SSE版本耗时:0.235834s
分片策略耗时:0.294212s

​ 图表展示如下：

算法12345
串行算法(s)0.750.770.750.690.88
Cache优化(s)0.450.470.450.450.49
SSE版本(s)0.230.240.230.230.27
分片策略(s)0.280.290.280.280.38
算法678910
串行算法(s)1.090.770.690.690.71
Cache优化(s)0.490.470.450.450.45
SSE版本(s)0.240.230.220.230.22
分片策略(s)0.290.290.280.280.29

在这里插入图片描述

​ 从图中可以明显看出，耗时最多的算法时串行算法，也是最原始的算法，Cache优化对串行算法有很明显的优化效果，时间减短大约40% ，但用时仍比SSE编程要长，SSE版本算法运行时间最短，采用分片策略后时间反而有点增长。

​ 由于串行算法没做任何优化，因而运行时间最长。Cache优化算法对串行算法的取址时间进行了压缩。而想要更短的运行时间就需要用到SIMD编程。分片策略比SSE版本用时较长的原因大概是分片数量不理想，并行成本消耗过高。

4 源码

​ 本次实验代码如下：

#include<iostream>
#include<stdlib.h>
#include <pmmintrin.h>
#include <stdio.h>
#include <algorithm>
#include<cmath>

using namespace std;

const int maxN = 512;
const int T = 64; // tile size

double mul(int n,float a[][maxN],float b[][maxN],float c[][maxN]);
double trans_mul(int n, float a[][maxN], float b[][maxN], float c[][maxN]);
double sse_mul(int n, float a[][maxN], float b[][maxN], float c[][maxN]);
double sse_tile(int n, float a[][maxN], float b[][maxN], float c[][maxN]);

int main(){
    int n = 512;
    srand((unsigned)time(NULL));
    float a[maxN][maxN];
    float b[maxN][maxN];
    float c[maxN][maxN];
    double mul_sum = 0;
    double trans_mul_sum = 0;
    double sse_mul_sum = 0;
    double sse_tile_sum = 0;
    for(int i = 0; i < n; i++)
    {
        for(int j=0; j < n; j++){
            a[i][j] = rand();
            b[i][j] = rand();
        }
    }
    for(int i=0;i<10;i++){
        cout<<"第"<<i+1<<"次运行结果:"<<endl;
        mul_sum += mul(n,a,b,c);
        trans_mul_sum += trans_mul(n,a,b,c);
        sse_mul_sum += sse_mul(n,a,b,c);
        sse_tile_sum += sse_tile(n,a,b,c);
        cout<<endl;
    }
    cout<<"平均耗时:"<<endl;
    cout<<"串行算法耗时:"<<mul_sum/10<<"s"<<endl;
    cout<<"Cache优化耗时:"<<trans_mul_sum/10<<"s"<<endl;
    cout<<"SSE版本耗时:"<<sse_mul_sum/10<<"s"<<endl;
    cout<<"分片策略耗时:"<<sse_tile_sum/10<<"s"<<endl;
}

double mul(int n,float a[][maxN],float b[][maxN],float c[][maxN]){ //串行算法 O(n) = n^3
    double time;
    clock_t start,end;
    start = clock();

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            c[i][j]= 0.0;
            for(int k = 0; k < n; k++){
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }

    end = clock();
    time = (double)(end-start);
    cout<<"串行算法耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}

double trans_mul(int n, float a[][maxN], float b[][maxN], float c[][maxN]){ // Cache优化 O(n) = n^3
    double time;
    clock_t start,end;
    start = clock();

    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]); 
    for (int i = 0; i < n; ++i) {  
        for (int j = 0; j < n; ++j) { 
            c[i][j] = 0.0;
            for (int k = 0; k < n; ++k) { 
                c[i][j] += a[i][k] * b[j][k];
                }
            }
    } // transposition
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]);

    end = clock();
    time = (double)(end-start);
    cout<<"Cache优化耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}

double sse_mul(int n, float a[][maxN], float b[][maxN], float c[][maxN]){ //SSE版本 O(n) = (n^3)/4
    double time;
    clock_t start,end;
    start = clock();

    __m128 t1, t2, sum;  //__m128 == float
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]); 
    for (int i = 0; i < n; ++i){ 
        for (int j = 0; j < n; ++j){ 
            c[i][j] = 0.0;
            sum = _mm_setzero_ps();  //Initialize
            for (int k = n - 4; k >= 0; k -= 4){ // sum every 4 elements 
                t1 = _mm_loadu_ps(a[i] + k); 
                t2 = _mm_loadu_ps(b[j] + k); 
                t1 = _mm_mul_ps(t1, t2);
                sum = _mm_add_ps(sum, t1);
            }
            sum = _mm_hadd_ps(sum, sum); 
            sum = _mm_hadd_ps(sum, sum); 
            _mm_store_ss(c[i] + j, sum);
            for (int k = (n % 4) - 1; k >= 0; --k){ // handle the last n%4elements
                c[i][j] += a[i][k] * b[j][k];
            }
        }
    } 
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]);

    end = clock();
    time = (double)(end-start);
    cout<<"SSE版本耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}

double sse_tile(int n, float a[][maxN], float b[][maxN], float c[][maxN]){ //分片策略  O(n) = n^3
    double time;
    clock_t start,end;
    start = clock();

    __m128 t1, t2, sum;
    float t;
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]); 
    for (int r = 0; r < n / T; ++r) 
        for (int q = 0; q < n / T; ++q) { 
            for (int i = 0; i < T; ++i) 
                for (int j = 0; j < T; ++j) 
                    c[r * T + i][q * T +j] = 0.0;
            for (int p = 0; p < n / T; ++p) { 
                for (int i = 0; i < T; ++i) 
                    for (int j = 0; j < T; ++j) { 
                        sum = _mm_setzero_ps();
                        for (int k = 0; k < T; k += 4){ //sum every 4th elements
                            t1 = _mm_loadu_ps(a[r * T + i] + p * T + k); 
                            t2 = _mm_loadu_ps(b[q * T + j] + p * T + k);
                            t1 = _mm_mul_ps(t1, t2); 
                            sum = _mm_add_ps(sum, t1);
                        }
                        sum = _mm_hadd_ps(sum, sum); 
                        sum = _mm_hadd_ps(sum, sum); 
                        _mm_store_ss(&t, sum);
                        c[r * T + i][q * T + j] += t;
                    }
            }
        } 
    for (int i = 0; i < n; ++i) 
        for (int j = 0; j < i; ++j) 
            swap(b[i][j], b[j][i]);

    end = clock();
    time = (double)(end-start);
    cout<<"分片策略耗时: "<<(time/CLOCKS_PER_SEC)<<"s"<<endl;
    return time/CLOCKS_PER_SEC;
}
vincent_nkcs
关注
  • 12
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
二维矩阵相乘的串行和并行实现
gukesdo的专栏
06-09 2110
通常的二维矩阵相乘的串行算法实现很常见，如下：  int m;//column of the Matrix  int A[][]; int B[][]; //two matrix used to do the multiplication  int C[][]; //used to strore the final result  int D[][][];//used to store the
计算机网络并行串行,串行&并行程序在效率上的简单比较及串行算法并行化zz
weixin_39575502的博客
06-21 809
串行&并行程序在效率上的简单比较问题：多核与单核的CPU在运行串行、并行程序时时，在效率上的差别。多核兴起：20世纪40年代第一台电子管计算机的发明标志计算工具进入了一个崭新的时代。20世纪50年代末，晶体管的发现促成了计算机技术的一大飞跃，其性能先之电子管计算机数十倍到数百倍以上。而之后集成电路时代的到来又为计算机的发展开辟了一个新的里程。20世纪70年代，集成电路技术能够将计算机的控制...
GPU编程(三): CPU与GPU的矩阵乘法对比
weixin_34092370的博客
01-21 925
目录 前言 代码 计时函数 最后 前言 在上一篇的最后, 我提到了一个矩阵乘法, 这次与CPU进行对比, 从中可以很明显GPU在并行计算上的优势. 计时函数 在贴出代码之前, 来看下我常用的计时函数, 可以精确到微秒级. 首先头文件是#include&lt;sys/time.h&gt;. 结构体为: struct timeval{ long tv_sec; /*秒*/ ...
矩阵乘法串行并行算法
12-19
512*512的矩阵，实现并行算法分行，分列，分块的做法以及串行算法的实现
串行计算机与并行计算、并发计算的比较
长林攻城狮的博客
01-15 9819
原文转自：从串行到并行，从并行到分布式 1. 概念 假设有AB两个任务，则串行、并行、并发的区别如图1所示。 串行 A和B两个任务运行在一个CPU线程上，在A任务执行完之前不可以执行B。即，在整个程序的运行过程中，仅存在一个运行上下文，即一个调用栈一个堆。程序会按顺序执行每个指令。 并行 并行性指两个或两个以上事件或活动在同一时刻发生。在多道程序环境下，并行性使多个程序同一时刻可在不同...
【Scala-spark.mlib】本地矩阵乘法计算效率比较（稠密稀疏哪家强？）
Jimmyshis
04-08 2039
矩阵乘法效率比较矩阵乘法效率比较底层实现 矩阵乘法   在 效率比较 底层实现    是
矩阵乘法MPI并行程序报告.pdf
06-06
2. **并行编程思想**：学会分析问题，设计并行算法，尤其是针对矩阵乘法这类适合并行计算的任务。 3. **性能分析**：理解并行程序的加速比概念，尽可能设计出性能高效的并行程序。 【实验要求】强调了使用MPI和...
并行矩阵乘法
09-24
编译和运行程序后，可以对比并行矩阵乘法和串行矩阵乘法的执行时间，以验证并行化的效果。 总的来说，这个项目提供了对并行计算和多线程编程的实际应用，对于理解并行矩阵乘法的原理和优化技巧非常有帮助。通过学习...
基于MapReduce的高阶矩阵乘法分布式并行算法研究
05-09
不过，我可以根据标题和描述中的关键信息，生成关于“基于MapReduce的高阶矩阵乘法分布式并行算法研究”这一主题的知识点。 MapReduce是一种由Google提出的大规模数据处理模型，它将复杂的、运行于大规模集群上的...
openmp矩阵乘法_openmp_并行矩阵乘法_
09-29
本篇文章将详细讲解如何使用OpenMP来并行化矩阵乘法，以提高计算效率。 首先，我们要理解矩阵乘法的基本概念。给定两个矩阵A (m×n) 和B (n×p)，它们的乘积C (m×p) 是通过以下公式计算得出的： ``` C[i][j] = Σ...
求矩阵最大特征值的并行和串形算法
11-27
求矩阵最大特征值的并行和串形算法
矩阵乘法并行CUDA程序
08-28
总之，通过理解并掌握CUDA编程，我们可以利用GPU的强大并行计算能力，大幅提高矩阵乘法的执行速度，为高性能计算和科学应用带来显著的性能提升。对于希望深入学习GPU并行计算的开发者来说，这是一个值得探索的重要...
并行矩阵乘法的实现与对比，CPU单线程串行//CPU双线程并行//CPU,PPL并行库//GPU,AMP并发//GPU,AMP分组优化
Npe_xl_violet的博客
05-21 760
并行矩阵乘法的实现与对比，CPU单线程串行/CPU双线程并行/CPU,PPL并行库/GPU,C++AMP并发/GPU,C++AMP分组优化 如题，我会细讲部分代码和原理，保证各位能看懂。然后我没有使用类的方式来封装，各位复制代码可以随意进行自我使用，怎么方便怎么来。 头文件 先贴出头文件matrix.h大致看一下： #pragma once #include <iostream> #include <amp.h> #include <WinBase.h> #include
矩阵相乘效率比较
legend_hua的博客
04-12 8717
牛客网上的一道题深度学习是当前很热门的机器学习算法，在深度学习中，涉及到大量的矩阵相乘，现在需要计算三个稠密矩阵A,B,C的乘积ABC,假设三个矩阵的尺寸分别为m*n，n*p，p*q，且m&lt;n&lt;p&lt;q，以下计算顺序效率最高的是（）A. ABC            B. (AC)B             C. A(BC)                D. 所有效率都相同解答：...
高性能计算实验——通用矩阵乘法串行编程的实现及优化
weixin_43973089的博客
04-19 3536
高性能计算实验——通用矩阵乘法串行编程的实现及优化1.实验目的1.1通用矩阵乘法1.2通用矩阵乘法优化1.3大规模矩阵计算优化2.实验过程和核心代码2.1通用矩阵乘法2.2通用矩阵乘法优化2.3大规模矩阵计算优化4.实验结果4.1通用矩阵乘法4.2Strassen算法5.实验感想 1.实验目的 1.1通用矩阵乘法 熟练掌握通用矩阵乘法的原理以及实现GEMM，为后续实验打下基础，用C 语言实现一个矩阵乘法。 1.2通用矩阵乘法优化 进一步熟悉矩阵乘法的实现，深入学习矩阵乘法的优化算法，学习矩阵乘法的复杂度分析
MPI并行程序编写与调试（MPI矩阵-向量乘法）
aiaias的博客
12-12 1435
1、编写程序 vim mpi_mat_vect_time.c 2、编译、运行OpenMP并行程序（MPI矩阵-向量乘法） mpicc -g -Wall -o mpi_mat_vect_time mpi_mat_vect_time.c mpiexec -n 4 ./mpi_mat_vect_time /* File: mpi_mat_vect_time.c * * Purpose: Implement parallel matrix-vector multiplication using *
矩阵乘法 mpi c语言,C语言基于MPI并行计算矩阵的乘法
weixin_35997546的博客
05-18 1445
浏览量：1,023(在苹果系统下，如果文章中的图片不能正常显示，请升级Safari浏览器到最新版本，或者使用Chrome、Firefox浏览器打开。)矩阵的计算是并行计算里的一个很重要的问题。矩阵是一种网格化的数据，是一组同类型数值的集合，矩阵的出现，使得代数系统更完善，对各种实际问题的求解产生了巨大的作用。但是其庞大的计算量往往令人生畏，稍微大一点的矩阵，计算就变得非常繁琐，不仅仅是人，而且串行...
并行处理 mpi矩阵乘法
热门推荐
qljessica123的专栏
01-11 1万+
基于MPI并行方法实现矩阵乘法 目录 1. 实验目的 3 2. 实验环境 4 3. 实验内容 4 3.1. 实验题目 4 3.2. 实验过程 5 3.2.1. 集群使用 5 3.2.2. 源码及解析 5 3.3. 执行时间截图 12 3.3.1. 基准程序参数设计 12 3.3.2. 运行结果截图 14 3.3.3. 稀疏/稠密矩阵参数设计 18 4. 实验结论 18
两种不同分块算法及基本矩阵乘法的毫秒级效率比较（横切、纵切、竖切进行矩阵分块以及运用多线程来优化的矩阵乘法。
m0_63689135的博客
12-26 305
【代码】两种不同分块算法及基本矩阵乘法的毫秒级效率比较（横切、纵切、竖切进行矩阵分块以及运用多线程来优化的矩阵乘法。
分别实现串行算法、catch优化、sse/avx版本、分片策略的矩阵乘法程序,并进行运行
最新发布
01-01
矩阵乘法是一个常见的运算任务，可以通过串行算法、catch优化、SSE/AVX版本和分片策略来实现。下面分别介绍这四种实现方法。 1. 串行算法： 串行算法是最基本的矩阵乘法实现方式。通过两层循环遍历矩阵A和矩阵B的每...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值