【MPI学习笔记】3：快速并行方阵和向量乘积+多机测试

简述

之前使用的是在一台机器上的，内存非常有限，而核心数也不是很多，为了减小机器承受的压力，每运行到某块*alloc出的内存必定不被使用时，就立即free掉，而在多机上，这样的压力分散到了多台机器上。按照这次作业的要求，需要让计算速度尽可能快，这样就应当能不free的尽量不free，能不同步的不做同步，从而快速得到结果，再去free申请来的内存。

程序中还有一些细节，如当j=0时，操作row_now[j]必定会比操作row_now[0]慢，因为对j的取值解析也需要一次访问内存，为了至高的速度考虑，程序中应尽量避免这样的浪费。

上次课时，何老师指出，不必要的calloc也是一种浪费，因为对内存的清空，即初始化全0，也是要耗费时间的。在个问题中这样做是冗余的，因此只需要在j=0时对其做赋值，而其它时候做+=操作。

另外，如果在for循环中只对游标等于某个数值时做if判断，是非常不值得的，因为if的条件判断也是要耗费时间的，所以这部分被我重构了。

代码

注释中，用old:标注的是之前的做法和考虑，new:标注是新的做法和考虑。

/*
15121856 刘知昊
第2次作业(方阵x向量按行分配,计时)
 */
#include<stdio.h>
#include<mpi.h>
#include<stdlib.h>
#include<time.h>

//方阵的维度
#define N 960000

time_t start,end;//开始和结束时间

int main()
{
    int *vec=NULL;//列向量
    //double *mat=NULL;//自己进程的那部分矩阵
    int my_rank;//自己进程的进程号
    int comm_sz;//总的进程数目
    int my_row;//本进程处理的行数
    int i,j;//通用游标
    double *result=NULL;//用来存本进程计算出的结果向量
    double *all_rst=NULL;//只给0号进程存总的结果
    double *row_now=NULL;//每个进程每次仅申请的一行

    /**********************/
    MPI_Init(NULL,NULL);
    MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
    MPI_Comm_size(MPI_COMM_WORLD,&comm_sz);

    //计时开始
    if(my_rank==0)
    {
        start=time(NULL);
    }

    //本进程处理的行数就是总阶数/进程数
    my_row=N/comm_sz;

    //为每个进程都申请空间
    vec=malloc(N*sizeof(int));
    //mat=malloc(N*my_row*sizeof(double));//这是个进程每次申请完
    row_now=malloc(N*sizeof(double));//这是每个进程每次仅申请一行
    result=malloc(my_row*sizeof(double));//old:为了初始值置0而使用calloc
    //new:为了效率而用malloc,只要在i=0时做赋值

    //向量的值的设定,使用memset会报错
    for(j=0;j<N;j++)
        vec[j]=1;


    //本行的值的设定
    //在实际使用时,这里是读入本进程应处理的下一行
    for(j=0;j<N;j++)
        row_now[j]=j;


    //复杂度O(N*my_row)=O(N*N/comm_sz)
    for(i=0;i<my_row;i++)
    {
        /*
        //本行的值的设定
        //在实际使用时,这里是读入本进程应处理的下一行
        for(j=0;j<N;j++)
            row_now[j]=j;
        */

        //j=0时做赋值,后面就都加上来,这样就不需malloc
        result[i]=row_now[0]*vec[0];

        for(j=1;j<N;j++)
        {
            /*old:
            //计算并加入到本进程结果向量的对应位置上
            if(j==0)
                result[i]=row_now[0]*vec[0];//用0比用j少一次向内存寻址!
            */
            //上面这种方式的缺陷在于,每次都要多执行一下if判断
            //即使是执行简单的if判断,在数量级很大时也是很耗时间的
            //所以拿到函数体外

            //计算并加入到本进程结果向量的对应位置上
            result[i]+=row_now[j]*vec[j];
        }

        //下次循环直接覆盖上次使用的值
        //因此不需free和重新申请row_now
    }

    //old:为了机器考虑,确定不再使用的空间立即free掉
    //free(row_now);
    //new:为了效率考虑,这里先不free

    //while(0){}//测试用

    //old:此处的进程同步是必要之举
    //MPI_Barrier(MPI_COMM_WORLD);
    //new:并不必要,Gather本身会去管理进程传来信息的位置

    //聚集给0号进程
    if(my_rank==0)
    {
        //先开辟存储空间
        all_rst=malloc(N*sizeof(double));

        //聚集
        MPI_Gather
            (
            result, /*发送内容的地址*/
            my_row, /*发送的长度*/
            MPI_DOUBLE, /*发送的数据类型*/
            all_rst, /*接收内容的地址*/
            my_row, /*接收的长度*/
            MPI_DOUBLE, /*接收的数据类型*/
            0, /*接收至哪个进程*/
            MPI_COMM_WORLD /*通信域*/
            );
    }
    else
    {
        //聚集
        MPI_Gather
            (
            result, /*发送内容的地址*/
            my_row, /*发送的长度*/
            MPI_DOUBLE, /*发送的数据类型*/
            all_rst, /*接收内容的地址*/
            my_row, /*接收的长度*/
            MPI_DOUBLE, /*接收的数据类型*/
            0, /*接收至哪个进程*/
            MPI_COMM_WORLD /*通信域*/
            );
    }

    //进程同步,让所有进程的资源都准备好
    //MPI_Barrier(MPI_COMM_WORLD);
    //new:不必要

    //old:为了机器考虑,确定不再使用的空间立即free掉
    //free(vec);
    //free(result);
    //free(mat);
    //new:为了效率考虑,这里先不free


    //0号进程负责输出
    if(my_rank==0)
    {
        //计时结束
        end =time(NULL);
        //计算时间  
        printf("time=%f\n",difftime(end,start)); 
        printf("The Result is:\n");
        //改变跨度可以采样获取结果,快速结束I/O
        for(i=0;i<N;i+=N/10)
            printf("%f\n",all_rst[i]);
    }

    MPI_Finalize();
    /**********************/

    //最终,free应无遗漏
    free(all_rst);
    //new:
    free(row_now);
    free(vec);
    free(result);

    return 0;
}

测试

因为有其他同学也在用，他们在做什么事会直接影响我测试出的时间，在4主机48进程下测试了三次，时间的单位是秒：

我试过，如果直接把上一次(没有做速度上的优化时)的代码-O3编译，然后4主机48进程下跑(也就是说单纯依赖核心数的增加，而不对代码做速度上的优化)时，这个时间是380秒左右，相比之下，依赖重构在速度上优化了一半左右的时间。

当然，对速度的追求，造成了内存的浪费。如果真的有OPT算法，那么内存的浪费也完全没有了(可惜只能想想)。