mpi实现矩阵乘法，卷积，池化（gemm,covn,pooling）

矩阵乘法：

卷积：

池化：

Mpi基本原理：

  1.什么是MPI

Massage Passing Interface:是消息传递函数库的标准规范，由MPI论坛开发。

一种新的库描述，不是一种语言。共有上百个函数调用接口，提供与C和Fortran语言的绑定

MPI是一种标准或规范的代表，而不是特指某一个对它的具体实现

MPI是一种消息传递编程模型，并成为这种编程模型的代表和事实上的标准

2.MPI的特点

MPI有以下的特点：

消息传递式并行程序设计

指用户必须通过显式地发送和接收消息来实现处理机间的数据交换。

在这种并行编程中，每个并行进程均有自己独立的地址空间，相互之间访问不能直接进行，必须通过显式的消息传递来实现。

这种编程方式是大规模并行处理机（MPP）和机群（Cluster）采用的主要编程方式。

并行计算粒度大，特别适合于大规模可扩展并行算法

用户决定问题分解策略、进程间的数据交换策略，在挖掘潜在并行性方面更主动,并行计算粒度大,特别适合于大规模可扩展并行算法

消息传递是当前并行计算领域的一个非常重要的并行程序设计方式

二、MPI的基本函数

MPI调用借口的总数虽然庞大，但根据实际编写MPI的经验，常用的MPI函数是以下6个：

MPI_Init(…);

MPI_Comm_size(…);

MPI_Comm_rank(…);

MPI_Send(…);

MPI_Recv(…);

MPI_Finalize();

三、MPI的通信机制

MPI是一种基于消息传递的编程模型，不同进程间通过消息交换数据。

1.MPI点对点通信类型

所谓点对点的通信就是一个进程跟另一个进程的通信，而下面的聚合通信就是一个进程和多个进程的通信。

  1. 标准模式：

该模式下MPI有可能先缓冲该消息，也可能直接发送，可理解为直接送信或通过邮局送信。是最常用的发送方式。

由MPI决定是否缓冲消息

没有足够的系统缓冲区时或出于性能的考虑，MPI可能进行直接拷贝：仅当相应的接收完成后，发送语句才能返回。

这里的系统缓冲区是指由MPI系统管理的缓冲区。而非进程管理的缓冲区。

MPI环境定义有三种缓冲区：应用缓冲区、系统缓冲区、用户向系统注册的通信用缓冲区

MPI缓冲消息：发送语句在相应的接收语句完成前返回。

这时后发送的结束或称发送的完成== 消息已从发送方发出，而不是滞留在发送方的系统缓冲区中。

该模式发送操作的成功与否依赖于接收操作，我们称之为非本地的，即发送操作的成功与否跟本地没关系。

矩阵乘法代码实现:

#include<stdio.h>
#include<stdlib.h>
#include<mpi.h>
#include<time.h>

int main(int argc,char *argv[])
{
    double start, stop;
    int i, j, k, l;
    int *a, *b, *c, *buffer, *ans;
    int size;
    size = atoi(argv[1]);
    int rank, numprocs, line;
    

    MPI_Init(&argc, &argv);//MPI Initialize
    MPI_Comm_rank(MPI_COMM_WORLD,&rank);//获得当前进程号
    MPI_Comm_size(MPI_COMM_WORLD,&numprocs);//获得进程个数

    line = size/numprocs;//将数据分为(进程数)个块,主进程也要处理数据
    a = (int*)malloc(sizeof(int)*size*size);
    b = (int*)malloc(sizeof(int)*size*size);
    c = (int*)malloc(sizeof(int)*size*size);
    //缓存大小大于等于要处理的数据大小，大于时只需关注实际数据那部分
    buffer = (int*)malloc(sizeof(int)*size*line);//数据分组大小
    ans = (int*)malloc(sizeof(int)*size*line);//保存数据块计算的结果

    //主进程对矩阵赋初值，并将矩阵N广播到各进程,将矩阵M分组广播到各进程
    if (rank==0)
    {
        printf("tast %d start\n", rank);
        //从文件中读入矩阵
        FILE *fp;

        fp=fopen("a.txt","r");//打开文件
        start = MPI_Wtime();
        for(i=0;i<size;i++) //读数据
            for(j=0;j<size;j++)
                a[i*size+j] = i*size+j;    
        //将矩阵N发送给其他从进程
        for (i=1;i<numprocs;i++)
        {
                MPI_Send(b,size*size,MPI_INT,i,0,MPI_COMM_WORLD);
        }
        //依次将a的各行发送给各从进程
        for (l=1; l<numprocs; l++)
        {
            MPI_Send(a+(l-1)*line*size,size*line,MPI_INT,l,1,MPI_COMM_WORLD);
        }
        //接收从进程计算的结果
        for (k=1;k<numprocs;k++)
        {
            MPI_Recv(ans,line*size,MPI_INT,k,3,MPI_COMM_WORLD,MPI_STATUS_IGNORE);
            //将结果传递给数组c
            for (i=0;i<line;i++)
            {
                for (j=0;j<size;j++)
                {
                    c[((k-1)*line+i)*size+j] = ans[i*size+j];
                }

            }
        }
        //计算a剩下的数据
        for (i=(numprocs-1)*line;i<size;i++)
        {
            for (j=0;j<size;j++)
            {
                int temp=0;
                for (k=0;k<size;k++)
                    temp += a[i*size+k]*b[k*size+j];
                c[i*size+j] = temp;
            }
        }

        fp=fopen("c.txt","w");
        for(i=0; i<size; i++){
            for(j=0; j<size; j++)
                fprintf(fp,"%d ",c[i*size+j]);
            fputc('\n',fp);
        }
        fclose(fp);
        //结果测试
        //统计时间
        stop = MPI_Wtime();
        printf("tast %d end\n", rank);
        printf("rank:%d time:%lfs\n",rank,stop-start); 

        free(a);
        free(b);
        free(c);
        free(buffer);
        free(ans);
        
    }

    //其他进程接收数据，计算结果后，发送给主进程
    else
    {
        printf("tast %d start\n", rank);
        //接收广播的数据(矩阵b)
        MPI_Recv(b,size*size,MPI_INT,0,0,MPI_COMM_WORLD,MPI_STATUS_IGNORE);

        MPI_Recv(buffer,size*line,MPI_INT,0,1,MPI_COMM_WORLD,MPI_STATUS_IGNORE);
        //计算乘积结果，并将结果发送给主进程
        for (i=0;i<line;i++)
        {
            for (j=0;j<size;j++)
            {
                int temp=0;
                for(k=0;k<size;k++)
                    temp += buffer[i*size+k]*b[k*size+j];
                ans[i*size+j]=temp;
            }
        }
        //将计算结果传送给主进程
        MPI_Send(ans,line*size,MPI_INT,0,3,MPI_COMM_WORLD);
        printf("tast %d end\n", rank);
    }

    MPI_Finalize();//结束

    return 0;
}

运行结果：

矩阵相乘：

 卷积代码实现：

#include <mpi.h>
#include <iostream>
#include <vector>
#include<time.h>

using namespace std;

// 定义卷积函数
vector<vector<double>> convolution(vector<vector<double>> image, vector<vector<double>> kernel) {
    int image_height = image.size();
    int image_width = image[0].size();
    int kernel_height = kernel.size();
    int kernel_width = kernel[0].size();
    int output_height = image_height - kernel_height + 1;
    int output_width = image_width - kernel_width + 1;
    vector<vector<double>> output(output_height, vector<double>(output_width, 0.0));
    for (int i = 0; i < output_height; i++) {
        for (int j = 0; j < output_width; j++) {
            for (int k = 0; k < kernel_height; k++) {
                for (int l = 0; l < kernel_width; l++) {
                    output[i][j] += image[i + k][j + l] * kernel[k][l];
                }
            }
        }
    }
    return output;
}

int main(int argc, char** argv) {
    MPI_Init(&argc, &argv);
    int rank, size;
    double start, stop;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    // 定义图像和卷积核
    vector<vector<double>> image = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
    vector<vector<double>> kernel = {{1, 0}, {0, 1}};
    

    


    // 计算每个进程需要处理的行数
    int rows_per_process = image.size() / size;
    int remainder = image.size() % size;
    int start_row = rank * rows_per_process;
    int end_row = start_row + rows_per_process;
    if (rank == size - 1) {
        end_row += remainder;
    }

    // 每个进程处理自己的部分图像
    vector<vector<double>> local_image(end_row - start_row, vector<double>(image[0].size(), 0.0));
    for (int i = start_row; i < end_row; i++) {
        for (int j = 0; j < image[0].size(); j++) {
            local_image[i - start_row][j] = image[i][j];
        }
    }

    // 每个进程计算自己的卷积结果
    vector<vector<double>> local_output = convolution(local_image, kernel);

    // 将每个进程的卷积结果发送给主进程
    if (rank == 0) {
        printf("tast %d start\n", rank);
        start = MPI_Wtime();
        vector<vector<double>> output(image.size() - kernel.size() + 1, vector<double>(image[0].size() - kernel[0].size() + 1, 0.0));
        for (int i = 0; i < local_output.size(); i++) {
            for (int j = 0; j < local_output[0].size(); j++) {
                output[i][j] = local_output[i][j];
            }
        }
        for (int i = 1; i < size; i++) {
            int start_row = i * rows_per_process;
            int end_row = start_row + rows_per_process;
            if (i == size - 1) {
                end_row += remainder;
            }
            vector<vector<double>> temp_output(end_row - start_row, vector<double>(image[0].size() - kernel[0].size() + 1, 0.0));
            MPI_Recv(&temp_output[0][0], (end_row - start_row) * (image[0].size() - kernel[0].size() + 1), MPI_DOUBLE, i, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            for (int j = start_row; j < end_row; j++) {
                for (int k = 0; k < image[0].size() - kernel[0].size() + 1; k++) {
                    output[j - kernel.size() + 1][k] = temp_output[j - start_row][k];
                }
            }
        }
        // 输出卷积结果
       // for (int i = 0; i < output.size(); i++) {
         //   for (int j = 0; j < output[0].size(); j++) {
           //     cout << output[i][j] << " ";
            //}
            //cout << endl;
        //}

        stop = MPI_Wtime();
        printf("tast %d end\n", rank);
        printf("rank:%d time:%lfs\n",rank,stop-start);

    } else {
        printf("tast %d start\n", rank);
        MPI_Send(&local_output[0][0], (end_row - start_row) * (image[0].size() - kernel[0].size() + 1), MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
        printf("tast %d end\n", rank);
    }

    MPI_Finalize();
    return 0;
}

运行结果：

卷积：

 池化代码实现：

#include <iostream>
#include <vector>
#include <mpi.h>
#include <climits>
using namespace std;

vector<vector<int>> max_pooling(vector<vector<int>> img, int kernel_size, int rank, int size) {
    int img_height = img.size();
    int img_width = img[0].size();
    int pool_height = img_height / kernel_size;
    int pool_width = img_width / kernel_size;
    int pool_size = pool_height * pool_width;
    int pool_per_process = pool_size / size;
    int remainder = pool_size % size;
    int start_index = rank * pool_per_process;
    int end_index = (rank + 1) * pool_per_process;
    if (rank == size - 1) {
        end_index += remainder;
    }
    vector<vector<int>> pool(end_index - start_index, vector<int>(1));
    int pool_index = 0;
    for (int i = 0; i < pool_height; i++) {
        for (int j = 0; j < pool_width; j++) {
            if (pool_index >= start_index && pool_index < end_index) {
                int max_val = INT_MIN;
                for (int k = 0; k < kernel_size; k++) {
                    for (int l = 0; l < kernel_size; l++) {
                        int val = img[i * kernel_size + k][j * kernel_size + l];
                        if (val > max_val) {
                            max_val = val;
                        }
                    }
                }
                pool[pool_index - start_index][0] = max_val;
            }
            pool_index++;
        }
    }
    return pool;
}

int main(int argc, char** argv) {
    int rank, size;
    double start, stop;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    int img_height = 8;
    int img_width = 8;
    int kernel_size = 4;
    vector<vector<int>> img(img_height, vector<int>(img_width));
    for (int i = 0; i < img_height; i++) {
        for (int j = 0; j < img_width; j++) {
            //img[i][j] = i * img_width + j + 1;
        }
    }
    vector<vector<int>> pool = max_pooling(img, kernel_size, rank, size);
    vector<vector<int>> all_pool(4 * 4, vector<int>(1));
    MPI_Gather(&pool[0][0], pool.size() * pool[0].size(), MPI_INT, &all_pool[0][0], pool.size() * pool[0].size(), MPI_INT, 0, MPI_COMM_WORLD);
    if (rank == 0) {
        //printf("task:%d start\n",rank);
        start = MPI_Wtime();
        for (int i = 0; i < all_pool.size(); i++) {
           cout << "";
        }
        cout << endl;
       // printf("task:%d end\n",rank);
    }
    
    stop = MPI_Wtime();
    if (rank == 0){
    printf("rank:%d time:%lfs\n",rank,stop-start); 
    }
    MPI_Finalize();
    return 0;
}

池化：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/30273.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

phpstorm+xdebug/php项目调试

phpstorm+xdebug/php项目调试

前提&#xff1a;项目使用xampp集成 一、下载xdebug&#xff0c;当到xampp/php/exp目录下 二、配置php.ini [Xdebug] zend_extension"D:/xampp/php/ext/php_xdebug.dll" xdebug.collect_paramsOn xdebug.collect_returnOn xdebug.auto_traceOn xdebug.trace_output_…
阅读更多...
android adb 获取电池信息以及设置

android adb 获取电池信息以及设置

本文主要包含 1、设置adb 无线调试桥连接步骤 2、打印设备电池状态(当前电量、充电状态、充放电电流大小、电池种类等&#xff09; 3、更改电池充电状态、电量百分比、电池还原命令 4、断开adb 远程调试桥 -----------------------------------------------------------------…
阅读更多...
【数据结构与算法分析】树上漫步之探究前序、中序、后序、广度优先遍历算法的实现与优化

【数据结构与算法分析】树上漫步之探究前序、中序、后序、广度优先遍历算法的实现与优化

文章目录 前言二叉树的遍历方式构建二叉树递归遍历二叉树非递归遍历二叉树层次遍历 示例二叉树结果总结 前言 二叉树是数据结构中最基本的数据结构之一&#xff0c;它在计算机科学中有着非常重要的应用。二叉树的遍历是指按照一定的顺序遍历二叉树中的所有节点&#xff0c;是二…
阅读更多...
【STM32训练—WiFi模块】第二篇、STM32驱动ESP8266WiFi模块获取天气

【STM32训练—WiFi模块】第二篇、STM32驱动ESP8266WiFi模块获取天气

目录 第一部分、前言 1、获取心知天气API接口 2、硬件准备 第二部分、电脑串口助手调试WIFI模块获取天气 1、ESP8266获取天气的流程 2、具体步骤 第三部分、STM32驱动ESP8266模块获取天气数据 1、天气数据的解析 1.1、什么函数来解析天气数据&#xff1f; 2.1、解析后…
阅读更多...
C语言之运算符

C语言之运算符

C语言运算符 文末附运算符的优先表和ASCII表 一、算术运算符 加(&#xff09;减&#xff08;—&#xff09;乘&#xff08;*&#xff09;除&#xff08;/&#xff09;模&#xff08;余&#xff09;运算符&#xff08;%&#xff09;&#xff1a;不允许出现浮点型&#xff0c;…
阅读更多...
Linux---详细讲解linux计算机体系结构

Linux---详细讲解linux计算机体系结构

前言 Linux是一种开源的操作系统&#xff0c;它的核心思想是基于冯诺依曼体系结构。在本文中&#xff0c;我们将深入探讨Linux的基本原理和操作系统的概念。 Linux是一款基于Unix操作系统的开源软件&#xff0c;它的核心是由Linus Torvalds在1991年开发的。Linux的出现&#x…
阅读更多...
CSS | CSS中height:100vh和height:100%的区别

CSS | CSS中height:100vh和height:100%的区别

目录 1、对于设置height:100%;有下面几种情况 2、对于设置height:100vh时有如下的情况 首先&#xff0c;我们得知道1vh它表示的是当前屏幕可见高度的1/100&#xff0c;而1%它表示的是父元素长或者宽的1% 1、对于设置height:100%;有下面几种情况 &#xff08;1&#xff09;当…
阅读更多...
Win10 hyper-v与vmware不兼容解决方案

Win10 hyper-v与vmware不兼容解决方案

Win10 hyper-v与vmware不兼容怎么办 一、异常1.1 异常描述 - V M w a r e W o r k s t a t i o n 与 H y p e r − V 不兼容 \color{red}{VMware Workstation 与 Hyper-V 不兼容} VMwareWorkstation与Hyper−V不兼容1.2 异常原因 二、解决办法2.1 关闭Hyper-V启动2.2 关闭内核…
阅读更多...
OpenGL 光照贴图

OpenGL 光照贴图

1.简介 现实世界中的物体通常并不只包含有一种材质&#xff0c;而是由多种材质所组成。想想一辆汽车&#xff1a;它的外壳非常有光泽&#xff0c;车窗会部分反射周围的环境&#xff0c;轮胎不会那么有光泽&#xff0c;所以它没有镜面高光&#xff0c;轮毂非常闪亮。 2.漫反射…
阅读更多...
pyspark安装教程

pyspark安装教程

pyspark安装教程 一、Windows下配置pyspark环境1.1 JDK下载安装1.2 Scala下载安装1.3 spark下载安装1.4 Hadoop下载安装1.5 pyspark下载安装 二、pyspark原理简介 一、Windows下配置pyspark环境 在python中使用pyspark并不是单纯的导入pyspark包就可以实现的&#xff0c;而是需…
阅读更多...
【SpringCloud入门】-- Nacos快速入门之搭建服务与注册中心

【SpringCloud入门】-- Nacos快速入门之搭建服务与注册中心

目录 前言&#xff1a; 1.Nacos的下载与安装 2. 去MySQL建立一个名为nacos的数据库 3.介绍配置文件&#xff0c;conf目录下的 application.properties 4.nacos启动 5. nacos作为注册中心的作用 6.建立一个项目&#xff0c;实现向命名空间注册 前言&#xff1a; 上文我们已…
阅读更多...
基于人工智能的AI理发师能帮托尼老师做什么？

基于人工智能的AI理发师能帮托尼老师做什么？

BarberGPT是一个人工智能理发师&#xff0c;它可以让您在照片上尝试不同的发型。您只需要上传您的照片&#xff0c;标记您的头发&#xff0c;然后就可以看到惊人的变化。BarberGPT使用了先进的深度学习技术&#xff0c;可以根据您的脸型、肤色和发质生成适合您的发型。BarberGP…
阅读更多...
MySql常见问题（长期更新）

MySql常见问题（长期更新）

基于mysql 8.0.3版本 一、忘记root密码1.1 、linux 系统下忘记密码1.2、Windows 系统下忘记密码1.3 Unix 和类 Unix 系统 二、账号问题2.1 远程访问账号设置 一、忘记root密码 1.1 、linux 系统下忘记密码 啥&#xff1f;你问我为什么会忘记密码&#xff1f;别问&#xff0c;…
阅读更多...
Spring Boot高阶篇笔记

Spring Boot高阶篇笔记

一、Spring Boot整合Redis缓存 JSR-107、Spring缓存抽象、整合Redis 1、JSR107 Java Caching定义了5个核心接口&#xff0c;分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。 • CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应…
阅读更多...
Oracle 查询优化改写（第一章）

Oracle 查询优化改写（第一章）

第一章 单表查询 1.查询空值 2.将空值转换为实际值 不采用nvl&#xff08;&#xff09;函数&#xff0c;而使用COALESCE函数语法为COALESCE(表达式1,表达式2,...,表达式n)&#xff0c;n>2,此表达式的功能为返回第一个不为空的表达式&#xff0c;如果都为空则返回空值。 注…
阅读更多...
tp6安装并使用rabbitMQ

tp6安装并使用rabbitMQ

最近因为业务需要,要用到MQ就去研究了一下,说实话,安装环境给我搞自闭了,大概是我太菜 刚开始使用yum换源,各种安装卸载始终找不到自己要用的版本,后来全部卸载,下载安装包 编译安装解百忧 我用的是erlang 25.3 的版本,MQ使用的是3.11.3的版本,符合官方要求,这里的版本是有强…
阅读更多...
TCP为什么要三次握手与四次分手？

TCP为什么要三次握手与四次分手？

概要 TCP协议是五层协议中运输层的协议&#xff0c;下面依赖网络层、链路层、物理层&#xff0c;对于一个报文想发到另一台机器(假设是服务器)上对等层&#xff0c;每一个所依赖的层都会对报文进行包装&#xff0c;例如TCP协议就依赖网络层的IP协议&#xff0c;所以发送的报文会…
阅读更多...
实习记录（二）Java常用工具库

实习记录（二）Java常用工具库

一.Lombok 1.背景概述 Lombok是一个非常高效的专用于Java的自动构建插件库&#xff0c;其简化了 JavaBean 的编写&#xff0c;避免了冗余和样板式代码的出现&#xff0c;让编写的类更加简洁明了&#xff0c;可以帮助大家节省很多重复低效的代码编写。比如重复性的Setter、Gett…
阅读更多...
日志是什么？耗时2个月搞懂Linux日志

日志是什么？耗时2个月搞懂Linux日志

这里写目录标题 日志基本介绍日志管理服务日志轮替 日志基本介绍 日志是用来记录重大事件的工具。 日志文件是重要的系统信息文件&#xff0c;其中记录了很多重要的系统事件。包括用户的登录信息&#xff0c;系统的启动信息&#xff0c;系统的安全信息&#xff0c;邮件相关信息…
阅读更多...
ChatGPT：数字时代革新与展望

ChatGPT：数字时代革新与展望

ChatGPT&#xff1a;数字时代革新与展望 AGI 未来的愿景&#xff1a;建安全有益的 AGI OpenAI团队对AGI的展望&#xff1a; 我们希望 AGI 能够赋予人类在宇宙中最大程度地繁荣发展的能力。我们不期望未来是一个不合格的乌托邦&#xff0c;但我们希望将好的最大化&#xff0c;将…
阅读更多...
最新文章

Copyright @ 2022~2023