Windows下多线程编程 C/C++ —— 矩阵乘法的并行算法

最新推荐文章于 2024-04-24 10:17:53 发布
最新推荐文章于 2024-04-24 10:17:53 发布
阅读量4.4k 收藏 60
点赞数 13
分类专栏： 计算机基础 文章标签： 算法 windows多线程 矩阵乘法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40515692/article/details/106749232
版权

一、串行算法

设两个矩阵A和B，大小分别为M * N 和 N * P， 如果C = A * B， 则C的大小为M * P。

相应的代码表示如下：

这里可能大家直观想法可能是int A[M][N]，但是这样的话二维传参比较麻烦。

然后如果是new/malloc二维数组的话，由于这样的数组每行之间不一定连续存储，所以可能不会有较好的cache命中率。

// int A[M * N], B[N * P], C[M * P];

void func(int *A, int *B, int *C, int M, int P, int N) {
    // C(M,P) = A(M,N) * B(N,P)
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < P; ++j) {
            C[i * P + j] = 0;
            for (int k = 0; k < N; ++k) {
                C[i * P + j] += A[i * N + k] * B[k * P + j];
            }
        }
    }
}

这里先给一个可以运行的代码：

#include <iostream>

using namespace std;

void func(int *A, int *B, int *C, int M, int P, int N) {
    // C(M,P) = A(M,N) * B(N,P)
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < P; ++j) {
            C[i * P + j] = 0;
            for (int k = 0; k < N; ++k) {
                C[i * P + j] += A[i * N + k] * B[k * P + j];
            }
        }
    }
}

void printM(int *A, int M, int N) {
    // print A(M,N)
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++)
            cout << A[i * N + j] << " ";
        cout << endl;
    }
    cout << endl;
}

const int M = 3, N = 3, P = 3;
int A[M * N], B[N * P], C[M * P];

int main() {
    for (int i = 0; i < M * N; i++) A[i] = i;
    for (int i = 0; i < N * P; i++) B[i] = i;
    func(A, B, C, M, P, N);
    printM(A, M, N);
    printM(B, N, P);
    printM(C, M, P);
    return 0;
}

运行结果如下：
在这里插入图片描述

二、并行算法

从上面的算法中可以看出该算法的时间复杂度为O(MNP)，当M,N,P都非常大时该计算将非常耗时。那么如何将上面的串行算法转换成并行算法呢？

这里选择的多线程库是windows自带的多线程（#include <windows.h>），作者刚学习windows自带的多线程，有任何问题欢迎指正。

首先是要考虑如何并行：

从上面的三层循环中可以看出最外层的两个循环是独立的，即对C(i,j)的计算不依赖于任何C(i,j)的计算，因此我们可以通过这个对每个线程分配任务。

假设有m个线程，矩阵C的元素有M*P个。那么平均到每个线程的计算C元素就是(M*P)/m个。所以我们先写一下每一个线程要执行的函数：

struct MYDATA { // 每个线程都会接受一个这样的结构体指针
    int begin, end;
    int *A, *B, *C;
    int P, N;
};

DWORD ThreadProc(LPVOID IpParam) {
    // 接受的数据
    MYDATA *pmd = (MYDATA *) IpParam;
    int *A = pmd->A, *B = pmd->B, *C = pmd->C;
    int begin = pmd->begin, end = pmd->end, P = pmd->P, N = pmd->N;
    
    // 矩阵运算，计算C的元素编号范围[begin,end)
    for (int index = begin; index < end; index++) {
        // 通过编号计算元素的行和列
        int i = index / P, j = index % P;
        C[i * P + j] = 0;
        for (int k = 0; k < N; ++k) {
            C[i * P + j] += A[i * N + k] * B[k * P + j];
        }
    }
    return 0;
}

接下来就是设计创建线程和传入参数了：

    // 假设m个线程，每个线程一个hThread和一个配套的mydt（static让变量的生命周期不局限于主函数内）
	const int m = 4;
    HANDLE hThread[m];
    static MYDATA mydt[m];
    
    // temp就是平均到每个线程的计算元素
    int temp = (M * P) / m;
    for (int i = 0; i < m; ++i) {
        mydt[i].A = A, mydt[i].B = B, mydt[i].C = C;
        mydt[i].begin = i * temp, mydt[i].end = i * temp + temp, mydt[i].P = P, mydt[i].N = N;
        if (i == m - 1) // 最后一个线程计算剩余的
            mydt[i].end = M * P;
        hThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) ThreadProc, &mydt[i], 0, NULL);
    }
    WaitForMultipleObjects(m, hThread, TRUE, INFINITE);

这里给出完整代码：

#include <windows.h>
#include <iostream>
#include <ctime>

using namespace std;

struct MYDATA {
    int begin, end;
    int *A, *B, *C;
    int P, N;
};

DWORD ThreadProc(LPVOID IpParam) {
    MYDATA *pmd = (MYDATA *) IpParam;
    int *A = pmd->A, *B = pmd->B, *C = pmd->C;
    int begin = pmd->begin, end = pmd->end, P = pmd->P, N = pmd->N;
    for (int index = begin; index < end; index++) {
        int i = index / P, j = index % P;
        C[i * P + j] = 0;
        for (int k = 0; k < N; ++k) {
            C[i * P + j] += A[i * N + k] * B[k * P + j];
        }
    }
    return 0;
}

void func(int *A, int *B, int *C, int M, int P, int N) {
    // C(M,P) = A(M,N) * B(N,P)
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < P; ++j) {
            C[i * P + j] = 0;
            for (int k = 0; k < N; ++k) {
                C[i * P + j] += A[i * N + k] * B[k * P + j];
            }
        }
    }
}

void printM(int *A, int M, int N) {
    // print A(M,N)
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++)
            cout << A[i * N + j] << " ";
        cout << endl;
    }
    cout << endl;
}

const int M = 1000, N = 1000, P = 1000;
int A[M * N], B[N * P], C[M * P];

int main() {
    clock_t startTime, endTime;
    startTime = clock();//计时开始

    for (int i = 0; i < M * N; i++) A[i] = i;
    for (int i = 0; i < N * P; i++) B[i] = i;

    // ----------------------------------- 多线程
    const int m = 4;
    HANDLE hThread[m];
    static MYDATA mydt[m];
    int temp = (M * P) / m;
    for (int i = 0; i < m; ++i) {
        mydt[i].A = A, mydt[i].B = B, mydt[i].C = C;
        mydt[i].begin = i * temp, mydt[i].end = i * temp + temp, mydt[i].P = P, mydt[i].N = N;
        if (i == m - 1) // 最后一个线程计算剩余的
            mydt[i].end = M * P;
        hThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) ThreadProc, &mydt[i], 0, NULL);
    }
    WaitForMultipleObjects(m, hThread, TRUE, INFINITE);

    // ----------------------------------- 串行
//    func(A, B, C, M, P, N);
//    printM(A, M, N);
//    printM(B, N, P);
//    printM(C, M, P);

    endTime = clock();//计时结束
    cout << "use time: " << (double) (endTime - startTime) / CLOCKS_PER_SEC << endl;
    return 0;
}

4个线程的用时为1.819s，1个线程的用时为7.219s（我的电脑是4核CPU）

优化

由于内存中二维数组是以行优先进行存储的（我们的一维数组在内存方面和二维数组没区别），因此 B[k * P + j]存在严重的cache命中率问题，解决这个问题的方法是也将B进行一次沿对角线进行翻转，使得最里面的计算变成 B[j * P + k]

优化后的完整代码如下：

#include <windows.h>
#include <iostream>
#include <ctime>

using namespace std;

struct MYDATA {
    int begin, end;
    int *A, *B, *C;
    int P, N;
};

DWORD ThreadProc(LPVOID IpParam) {
    MYDATA *pmd = (MYDATA *) IpParam;
    int *A = pmd->A, *B = pmd->B, *C = pmd->C;
    int begin = pmd->begin, end = pmd->end, P = pmd->P, N = pmd->N;

    // 线程多的话，这个最好应该提出来
    int sizeB = N * P;
    int *revB = new int[sizeB];
    for (int index = 0; index < sizeB; index++) {
        int i = index / P, j = index % P;
        revB[i * P + j] = B[j * P + i];
    }

    for (int index = begin; index < end; index++) {
        int i = index / P, j = index % P;
        C[i * P + j] = 0;
        for (int k = 0; k < N; ++k) {
            C[i * P + j] += A[i * N + k] * revB[j * P + k];
        }
    }
    delete[]revB;
    return 0;
}

void func(int *A, int *B, int *C, int M, int P, int N) {
    // C(M,P) = A(M,N) * B(N,P)
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < P; ++j) {
            C[i * P + j] = 0;
            for (int k = 0; k < N; ++k) {
                C[i * P + j] += A[i * N + k] * B[k * P + j];
            }
        }
    }
}

void printM(int *A, int M, int N) {
    // print A(M,N)
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++)
            cout << A[i * N + j] << " ";
        cout << endl;
    }
    cout << endl;
}

const int M = 1000, N = 1000, P = 1000;
int A[M * N], B[N * P], C[M * P];

int main() {
    clock_t startTime, endTime;
    startTime = clock();//计时开始

    for (int i = 0; i < M * N; i++) A[i] = i;
    for (int i = 0; i < N * P; i++) B[i] = i;

    // ----------------------------------- 多线程
    const int m = 4;
    HANDLE hThread[m];
    static MYDATA mydt[m];
    int temp = (M * P) / m;
    for (int i = 0; i < m; ++i) {
        mydt[i].A = A, mydt[i].B = B, mydt[i].C = C;
        mydt[i].begin = i * temp, mydt[i].end = i * temp + temp, mydt[i].P = P, mydt[i].N = N;
        if (i == m - 1) // 最后一个线程计算剩余的
            mydt[i].end = M * P;
        hThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) ThreadProc, &mydt[i], 0, NULL);
    }
    WaitForMultipleObjects(m, hThread, TRUE, INFINITE);

    // ----------------------------------- 串行
//    func(A, B, C, M, P, N);
//    printM(A, M, N);
//    printM(B, N, P);
//    printM(C, M, P);

    endTime = clock();//计时结束
    cout << "use time: " << (double) (endTime - startTime) / CLOCKS_PER_SEC << endl;
    return 0;
}

4个线程的用时为1.199s，可以看到效果还是很显著的。

参考文章： https://blog.csdn.net/realxie/article/details/7260072

iamttp
关注
  • 13
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
操作系统实验——矩阵乘法
永不止步的博客
06-17 2609
实验任务 在windows操作系统上，利用Windows API编写程序用多线程实现矩阵乘法。实现A、B两个矩阵的乘法，并输出计算结果。 该实验相对比较简单，可先看实验报告的实验步骤，然后需要了解一下几个关于pthread里的函数使用： （1）pthread_join函数： 函数pthread_join用来等待一个线程的结束。 函数定义： int pthread_join(pt...
windows下多线程编程完成矩阵乘法
04-12
windows下多线程编程完成矩阵乘法，从而提高效率
Linux多线程矩阵,操作系统实验(进程)多线程实现矩阵乘法
weixin_42356292的博客
05-06 1191
《操作系统实验(进程)多线程实现矩阵乘法》由会员分享，可在线阅读，更多相关《操作系统实验(进程)多线程实现矩阵乘法(6页珍藏版)》请在人人文库网上搜索。1、多线程编程实现矩阵乘法一、实验目的通过实验，熟悉基于Win32线程库和Pthread线程库的编程环境，掌握利用Windows API和Pthread API进行多线程编程的方法，进一步加深对线程概念以及多线程编程相关事项的理解。二、实验内容1....
矩阵按列相乘运算的并行化实现方法
最新发布
彬彬有礼的专栏
04-24 525
也就是说，矩阵Z中的第(r,s)个元素等于X的第r行之和乘以Y的第s行之和。因此，可以先分别将X和Y所有列对应相加，得到长为d的列向量Xsum和Ysum，则Z等于Xsum乘以Ysum的转置。注意到第一个括号是将X所有列对应相加，第二个括号是将Y所有列对应相加，因此Z也就是前面提到的Xsum乘以Ysum的转置。其中X(:,i), Y(:,j)分别表示矩阵X, Y的第i列和第j列，易知Z为d×h矩阵。注意到第一个括号是X的第r行之和，第二个括号是Y的第s行之和。这两天一直在琢磨如下矩阵计算问题。
windows下c语言实现多线程矩阵乘法
qq_45366264的博客
10-28 1329
同学问我的一道多线程编程题，ta希望能在windows下用c语言来编写。然而我在网络上找到的资源太少，要不就是用linux操作系统，要不就是用c++/java/python编写，故在此做个记录，希望能帮助到需要的人。 1. 分析 1. 总体思想 定义三个矩阵C1,C2,C3，将C1与C2的每行、每列的乘积放入C3中，即 C3ij=∑C1ik∗C2kj,k=0,1,...,nC3_{ij}=\sum{C1_{ik}*C2_{kj}},k=0,1,...,nC3ij​=∑C1ik​∗C2kj​,k=0
OpenMP 之 矩阵乘法实现 （星星笔记）
热门推荐
Growth Diary
09-10 1万+
用OpenMP编写两个n阶的方阵A和B的相乘程序，结果存放在方阵c中，其中乘法用for编译制导语句实现并行化操作，并调节for编译制导中schedule的参数，使得执行时间最短，写出代码。 方阵a和b的初始值如下：   输入： 方阵的阶n、并行域的线程数 输出： c中所有元素之和、程序的执行时间
C++ 矩阵乘并行算法实现
04-06
由用户指定矩阵维数，程序会随机生成相应维数的矩阵，调用MPI中的相关函数，模拟并行算法计算得出矩阵乘的结果
Linux多线程编程
ywd171的博客
11-24 3496
任务1： 要求：编写程序task61.c，主线程创建3个对等线程T1、T2、T3，每个线程利用循环执行5次printf输出操作，两次循环间随机等待1-5s时间。主线程等待所有对等线程结束后终止进程。各对等线程的输出操作是： T1：输出“My name is <您的姓名xxx>” T2：输出“My student number is <您的学号xxx>” T3：输出“Current time <当前时间，包括年月日时分秒> 要求： 采用文件复制、文本复制或输入方式
新建文件夹.rar_Windows编程_C/C++__Windows编程_C/C++_
08-09
8. **多线程编程**：Windows平台支持多线程，C/C++程序员可以创建和管理多个并发执行的线程，以提高程序的并行处理能力。 9. **异常处理**：在Windows编程中，良好的错误和异常处理机制对于保证程序的健壮性至关...
CodedTargetDecoder.zip_Windows编程_C/C++__Windows编程_C/C++_
08-09
这可能涉及算法的选择、内存管理策略、多线程编程（如使用OpenMP）以及CPU/GPU并行计算。 总之，"CodedTargetDecoder.zip"项目涵盖了一系列的C/C++编程、Windows平台开发、图像处理和计算机视觉技术。通过深入学习...
C-SOFTCOPY.zip_Windows编程_C/C++_
08-11
8. OpenMP：如果需要进一步提升并行处理能力，可以使用OpenMP库，它为C/C++提供了并行化编程的接口，可以轻松实现基于共享内存的多线程并行。 9. 编译与调试：使用Visual Studio等IDE进行项目构建和调试，可以方便...
并行矩阵乘法
09-24
基于Pthread的多线程并行矩阵乘法，包含1000*1000矩阵随机矩阵生成代码，和串行矩阵乘法的比较，c++实现，Windows系统。
多线程矩阵乘法
05-28
给定两个矩阵 A和 B，其中 A是具有 M行、 K列的矩阵， B为 K行、 N列的矩阵， A和 B的矩阵积为C
Sources1.zip_Windows编程_C/C++_
08-12
2. **多线程编程**：在Windows上，C/C++程序可以创建多个线程来实现并发执行。这在处理实时任务，如智能车控制，时非常有用。线程同步机制，如互斥量、信号量、事件对象，确保了共享资源的安全访问。 3. **文件系统...
qr_rect.rar_Windows编程_C/C++_
08-11
此外，Windows编程中，可能还需要关注多线程并行计算的可能性，比如利用OpenMP库进行并行化处理，以提高大型矩阵计算的效率。同时，为了确保程序的可读性和可维护性，良好的编程规范和注释也是必不可少的。 总之，...
c 语言编写矩阵乘法,用C++编写矩阵乘法运算的程序
weixin_29449593的博客
05-17 1311
方法一：使用指针二维数组#includeusing namespace std;int main() {int m;int n;int r;cout << "运算矩阵A和矩阵B相乘" << endl << endl;cout << "请输入矩阵A的行数和列数：" << endl << endl;cout << "矩...
矩阵乘法 mpi c语言,C语言基于MPI并行计算矩阵的乘法
weixin_35997546的博客
05-18 1415
浏览量：1,023(在苹果系统下，如果文章中的图片不能正常显示，请升级Safari浏览器到最新版本，或者使用Chrome、Firefox浏览器打开。)矩阵的计算是并行计算里的一个很重要的问题。矩阵是一种网格化的数据，是一组同类型数值的集合，矩阵的出现，使得代数系统更完善，对各种实际问题的求解产生了巨大的作用。但是其庞大的计算量往往令人生畏，稍微大一点的矩阵，计算就变得非常繁琐，不仅仅是人，而且串行...
c++（练习题01）
缘友一世的博客
04-03 1719
文章目录冒泡排序选择排序 冒泡排序 描述 键盘随机输入 6 个整数，将这些数据保存到数组中，使用冒泡排序对数组中的元素进行从小到大顺序排序，输出排序后数组中的元素（元素之间使用空格隔开）。 输入描述：键盘随机输入 6 个整数 输出描述：输出排序后数组中的元素（元素之间使用空格隔开） 输入： 24 69 80 57 13 16 输出： 13 16 24 57 69 80 #include <iostream> using namespace std; int main() { int
《多核程序设计》学习笔记：矩阵乘法并行化
weixin_34236869的博客
07-28 420
2019独角兽企业重金招聘Python工程师标准>>> ...
Parallel Programming in Visual C++
01-22
微软官方文档：https://github.com/MicrosoftDocs/cpp-docs/tree/master/docs/parallel 修改了目录错乱的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值