transpose.c
上传用户:hhyinxing
上传日期:2013-09-10
资源大小:833k
文件大小:6k
源码类别:

并行计算

开发平台:

Unix_Linux

  1. #include "stdio.h"
  2. #include "stdlib.h"
  3. #include "mpi.h"
  4. #include "math.h"
  5. #define E 0.0001
  6. #define a(x,y) a[x*m+y]
  7. #define b(x,y) b[x*m+y]
  8. #define A(x,y) A[x*size+y]
  9. #define B(x,y) B[x*size+y]
  10. #define intsize sizeof(int)
  11. #define floatsize sizeof(float)
  12. #define charsize sizeof(char)
  13. int size,N;                                       /* size:保存矩阵行数;N:保存矩阵列数 */
  14. int m;                                            /* 保存子方阵的尺寸 */
  15. int t;                                            /* 棋盘划分的分割数 */
  16. float *A, *B;                                     /* A:保存原矩阵;B:保存转置后的矩阵 */
  17. double starttime;                                 /* 保存开始时间 */
  18. double time1;                                     /* 保存分发数据的结束时间 */
  19. double time2;                                     /* 保存运行的结束时间 */
  20. int my_rank;                                      /* 保存当前进程的进程号 */
  21. int p;                                            /* 保存进程数 */
  22. MPI_Status status;                                /* 保存MPI状态 */
  23. FILE *fdA;                                        /* 输入文件 */
  24. /* 运行结束前,调用本函数释放内存空间 */
  25. void Environment_Finalize(float *a,float *b)
  26. {
  27.     free(a);
  28.     free(b);
  29. }
  30. int main(int argc, char **argv)
  31. {
  32.     int i,j,k,my_rank,group_size;
  33.     float *a,*b;
  34.     int u,v;
  35.     float temp;
  36.     MPI_Init(&argc,&argv);
  37.     MPI_Comm_size(MPI_COMM_WORLD,&group_size);
  38.     MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
  39.     p=group_size;
  40.     /* 如果是主进程(rank=0的进程),则进行读文件的操作,
  41.        将待转置的矩阵读入内存,保存到全局变量A中
  42.     */
  43.     if(my_rank==0)
  44.     {
  45.         starttime=MPI_Wtime();
  46.         fdA=fopen("dataIn.txt","r");
  47.         /* 读入矩阵的行数和列数,并保存到size和N中 */
  48.         fscanf(fdA,"%d %d", &size, &N);
  49.         /* 判断是否是方阵,如果不是,程序退出 */
  50.         if(size != N)
  51.         {
  52.             puts("The input is error!");
  53.             exit(0);
  54.         }
  55.         A=(float*)malloc(floatsize*size*size);
  56.         B=(float*)malloc(floatsize*size*size);
  57.         /* 将矩阵的所有值读入,保存到A中 */
  58.         for(i = 0; i < size; i ++)
  59.         {
  60.             for(j = 0; j < size; j ++) fscanf(fdA, "%f", A+i*size+j);
  61.         }
  62.         fclose(fdA);
  63.     }
  64.     /* 广播矩阵的尺寸 */
  65.     MPI_Bcast(&size,1,MPI_INT,0,MPI_COMM_WORLD);
  66.     /* 获得棋盘划分的数目 */
  67.     t=(int)sqrt(p);
  68.     if (t>size)
  69.         t=size;
  70.     if(size%t!=0)
  71.         for(;;)
  72.     {
  73.         t--;
  74.         if(size%t==0)
  75.             break;
  76.     }
  77.     /* 获得实际利用的处理器个数 */
  78.     p=t*t;
  79.     /* 每个子方阵的尺寸 */
  80.     m=size/t;
  81.     /* a保存子方阵,b是临时矩阵,是主进程用来保存待发送给别的进程的子方阵 */
  82.     a=(float *)malloc(floatsize*m*m);
  83.     b=(float *)malloc(floatsize*m*m);
  84.     if (a==NULL||b==NULL)
  85.         printf("allocate space  fail!");
  86.     /* 对主进程,获得自己的子方阵(即左上角的子方阵) */
  87.     if (my_rank==0)
  88.     {
  89.         for(i=0;i<m;i++)
  90.             for(j=0;j<m;j++)
  91.                 a(i,j)=A(i,j);
  92.     }
  93.     /* 主进程向其他进程发送数据 */
  94.     if (my_rank==0)
  95.     {
  96.         for(i=1;i<p;i++)
  97.         {
  98.             v=i/t;                                /* 子方阵的行号 */
  99.             u=i%t;                                /* 子方阵的列号 */
  100.             for(j=v*m;j<(v+1)*m;j++)
  101.                 for(k=u*m;k<(u+1)*m;k++)
  102.                     b((j%m),(k%m))=A(j,k);        /* 将子方阵暂存在b中 */
  103.                                                   /* 将子方阵发送到相应的进程 */
  104.             MPI_Send(b,m*m,MPI_FLOAT,i,i,MPI_COMM_WORLD);
  105.         }
  106.     }
  107.     else if (my_rank<p)                           /* 对其他进程,从主进程接收数据 */
  108.         MPI_Recv(a,m*m,MPI_FLOAT,0,my_rank,MPI_COMM_WORLD,&status);
  109.     time1=MPI_Wtime();
  110.     /* 对下三角的子方阵进行处理 */
  111.     if ((my_rank/t)>(my_rank%t)&&my_rank<p)
  112.     {
  113.         v=my_rank/t;                              /* 行号 */
  114.         u=my_rank%t;                              /* 列号 */
  115.         /* 发送子方阵到位于相应上三角位置的进程 */
  116.         MPI_Send(a,m*m,MPI_FLOAT,(u*t+v),(u*t+v),MPI_COMM_WORLD);
  117.         /* 从相应上三角位置的进程接收数据 */
  118.         MPI_Recv(a,m*m,MPI_FLOAT,(u*t+v),my_rank,MPI_COMM_WORLD,&status);
  119.     }
  120.     /* 对上三角的子方阵进行处理 */
  121.     if ((my_rank/t)<(my_rank%t)&&my_rank<p)
  122.     {
  123.         v=my_rank/t;                              /* 行号 */
  124.         u=my_rank%t;                              /* 列号 */
  125.         /* 将子方阵元素复制到b */
  126.         for(i=0;i<m;i++)
  127.             for(j=0;j<m;j++)
  128.                 b(i,j)=a(i,j);
  129.         /* 从相应下三角位置的进程接收数据 */
  130.         MPI_Recv(a,m*m,MPI_FLOAT,(u*t+v),my_rank,MPI_COMM_WORLD,&status);
  131.         /* 子方阵发送到位于相应下三角位置的进程 */
  132.         MPI_Send(b,m*m,MPI_FLOAT,(u*t+v),(u*t+v),MPI_COMM_WORLD);
  133.     }
  134.     /* 对每一个子方阵进行转置 */
  135.     for(i=1;i<m;i++)
  136.         for(j=0;j<i;j++)
  137.     {
  138.         temp=a(i,j);
  139.         a(i,j)=a(j,i);
  140.         a(j,i)=temp;
  141.     }
  142.     /* 主进程开始将转置的结果进行组合
  143.        先将主进程的结果组合到B中左上角
  144.     */
  145.     if (my_rank==0)
  146.     {
  147.         for(i=0;i<m;i++)
  148.             for(j=0;j<m;j++)
  149.                 B(i,j)=a(i,j);
  150.     }
  151.     /* 主进程从其他进程接收结果,组合到B的相应位置 */
  152.     if (my_rank==0)
  153.     {
  154.         for(i=1;i<p;i++)
  155.         {
  156.             /* 从其他进程接收结果 */
  157.             MPI_Recv(a,m*m,MPI_FLOAT,i,i,MPI_COMM_WORLD,&status);
  158.             v=i/t;                                /* 结果的行号 */
  159.             u=i%t;                                /* 结果的列号 */
  160.             for(j=v*m;j<(v+1)*m;j++)
  161.                 for(k=u*m;k<(u+1)*m;k++)
  162.                     B(j,k)=a((j%m),(k%m));        /* 结果组合到B的相应位置 */
  163.         }
  164.     }
  165.     else if(my_rank<p)                            /* 其他进程发送结果到主进程 */
  166.         MPI_Send(a,m*m,MPI_FLOAT,0,my_rank,MPI_COMM_WORLD);
  167.     /* 由主进程打印计算结果 */
  168.     if (my_rank==0)
  169.     {
  170.         printf("Input of file "dataIn.txt"n");
  171.         printf("%dt%dn", size, size);
  172.         for(i=0;i<size;i++)
  173.         {
  174.             for(j=0;j<size;j++) printf("%ft",A(i,j));
  175.             printf("n");
  176.         }
  177.         printf("nOutput of Matrix ATn");
  178.         for(i=0;i<size;i++)
  179.         {
  180.             for(j=0;j<size;j++) printf("%ft",B(i,j));
  181.             printf("n");
  182.         }
  183.     }
  184.     time2=MPI_Wtime();
  185.     /* 由主进程打印时间信息 */
  186.     if (my_rank==0)
  187.     {
  188.         printf("n");
  189.         printf("Whole running time    = %f secondsn",time2-starttime);
  190.         printf("Distribute data time  = %f secondsn",time1-starttime);
  191.         printf("Parallel compute time = %f secondsn",time2-time1);
  192.     }
  193.     MPI_Barrier(MPI_COMM_WORLD);
  194.     MPI_Finalize();
  195.     Environment_Finalize(a,b);
  196.     return(0);
  197. }