C 分布式矩阵转置过程模板笛卡尔

我一直在尝试实现一个分布式矩阵转置程序。其主要思想是为每个处理器建立一个模板（pxq），并使用该模板在处理器之间分割矩阵，然后在处理器之间分配块后使用块循环分布。 我想做的是在下面链接中的一篇简单的文章中

我已从您的网站上查看了以下答案：

。。当你使用MPI_create时似乎没什么问题，在我的代码中，我实际上使用了MPI_Cart，笛卡尔拓扑，但我半途而废，因为我不明白他们在论文中做了什么。他们如何在不同处理器之间分配块（如何在这些处理器之间循环编程2D块）

那么我的问题是，如果你能帮助我：

如何准确地编码二维块循环（如果我们说我们有12x12矩阵，每个处理器有3x4模板）

你能检查一下上面的链接，看看他们是如何在处理器之间分配块的吗？需要我能得到的任何帮助！我绝望了，最后我要继续笛卡尔拓扑吗

下面是我的代码，部分代码，不知道下一步是什么：

#include "mpi.h"
#include <stdio.h>

#define NP 4 // number of processors
#define M_ROW 4 //template of processor row
#define M_COL 3 //template of processor col

int main(int argc, char *argv[])
{
    int myid, numprocs;
    MPI_Comm comm;
    int dim[2], period[2], reorder;
    int coord[2];

    int A[8][6], array_P[M_ROW][M_COL]; //, AT[8][6];
    int n =0, Temp;
    int TT[8][6];

    int iv, jv, rankid; // for coordinates of each processor in the Cartesian matrix
    int k, y, i,j;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);


    // First: building the matrix

      for (i = 0; i < 8; i++) 
        for (j = 0; j < 6; j++)
            {
          A[i][j] = n;
          n++;
        }

    //Second to the virtual matrix with each processor having cartesian Coord.

    dim[0]= 2; // dimension
    dim[1]= 2; // dimensions assign for Cartesian

    period[0]=1; period[1]=1;  //row periodic + col periodic (each column/row forms a ring)
    reorder=1; // here is false in meaning to allow the reordering of the processors

    MPI_Cart_create(MPI_COMM_WORLD, 2, dim, period, reorder, &comm);
    MPI_Comm_rank(comm, &rankid); // creating rank for each processor location
    MPI_Cart_coords(comm, rankid, 2, coord); // creating coordinates for each Prc.

    MPI_Barrier(MPI_COMM_WORLD);

    iv = coord[0];
    jv = coord[1];


    //printf("Processor Rank %d receive dimensions (iv,jv)-> iv: %d ,jv: %d \n", myid, coord[0], coord[1]);


    for (k=0; k<M_ROW; k++)
    {
        for (y=0; y<M_COL; y++)
        {
            i = k + iv*M_ROW; 
            j = y + jv*M_COL;
            //array_P[k][y] = i*10 + j;
            array_P[k][y] = A[i][j];
        }
    }//end loop of filling data

    //("Processor %d: Before Transpose:\n", myid);

        if(myid == 3)
        {
        for (k=0; k<M_ROW; k++) // 3 ?? NBLK_R;
        {
            j = k + iv*M_ROW;       
            for (y=0; y<M_COL; y++) // 2 ?
            {
                i = y + jv*M_COL;
                printf(" %d    ", A[j][i]);
            }
        printf("\n");
        }  
        }

    printf("\n");




    //MPI_Alltoall(TT, M_ROW*M_COL, MPI_INT, TT, M_ROW*M_COL, MPI_INT, MPI_COMM_WORLD);

        /*
        if(myid == 2)
        {
        for (k=0; k<M_ROW; k++) // 3 ?? NBLK_R;
        {
            // = k + iv*M_ROW;      
            for (y=0; y<M_COL; y++) // 2 ?
            {
                //i = y + jv*M_COL;
                //Final[j][i] = array_PT[x][y];// check the arraypt ?
                printf(" %d    ", array_P[k][y]);
            }
        printf("\n");
        }  
        } */

    //Fourth - transposing the original matrix

    for (k=0; k<M_ROW; k++)
    {
        for (y=0; y<M_COL; y++)
        {
            i = k + iv*M_ROW; 
            j = y + jv*M_COL;
            Temp = A[i][j];
            A[i][j] = A[j][i];
            A[j][i] = Temp;

        }
    }


    printf("\n \n");

    if(myid == 3)
        {
        for (k=0; k<M_ROW; k++) // 3 ?? NBLK_R;
        {
            j = k + iv*M_ROW;       
            for (y=0; y<M_COL; y++) // 2 ?
            {
                i = y + jv*M_COL;
                printf(" %d    ", A[j][i]);
            }
        printf("\n");
        }  
        }

    printf("\n");




    //MPI_Barrier(comm);

    // send to main process - process 0 in our case - all the array_PT transposed
    // ml*nl -> 2*3
    //MPI_Send(array_PT,M_COL*M_ROW , MPI_INT, 0, 1, comm);

    //MPI_Isend(array_PT,M_COL*M_ROW , MPI_INT, 0, 1, comm, &request);

    //MPI_Barrier(MPI_COMM_WORLD);

    //int iv_tt , jv_tt;

    //******************************

    MPI_Finalize();
    return 0;
}

#包括“mpi.h”
#包括
#定义NP 4//处理器数量
#定义M_第4行//处理器行的模板
#定义M_COL 3//处理器COL的模板
int main（int argc，char*argv[]）
{
int myid，numprocs；
MPI_通信；
int dim[2]，期间[2]，重新排序；
国际合作[2]；
int A[8][6]，数组_P[M_ROW][M_COL]；/，位于[8][6]；
int n=0，温度；
int TT[8][6]；
int iv，jv，rankid；//笛卡尔矩阵中每个处理器的坐标
int k，y，i，j；
MPI_Init（&argc，&argv）；
MPI通信等级（MPI通信世界和myid）；
MPI通信大小（MPI通信世界和numprocs）；
//第一：构建矩阵
对于（i=0；i<8；i++）
对于（j=0；j<6；j++）
{
A[i][j]=n；
n++；
}
//其次是虚拟矩阵，每个处理器都有笛卡尔坐标。
维度[0]=2；//维度
dim[1]=2；//为笛卡尔坐标系指定维度
句点[0]=1；句点[1]=1；//行周期+列周期（每列/行形成一个环）
reorder=1；//此处为false，表示允许处理器重新排序
MPI_Cart_create（MPI_COMM_WORLD，2，dim，period，reorder，&COMM）；
MPI_Comm_rank（Comm，&rankid）；//为每个处理器位置创建列组
MPI_Cart_coords（comm，rankid，2，coord）；//为每个Prc创建坐标。
MPI_屏障（MPI_通信世界）；
iv=坐标[0]；
jv=coord[1]；
//printf（“处理器秩%d接收维度（iv，jv）->iv:%d，jv:%d\n”，myid，coord[0]，coord[1]）；
对于（k=0；k类似这样的事情？你的论文链接不起作用，也不清楚你想在这里做什么-听起来你当前的问题开始起作用了，是吗？什么现在不起作用了？我可以设法使用MPI\u Cart\u创建，主要是我做虚拟表，&分配每个处理器坐标，&在每个进程中r有块的数量，我的问题是：如何使用“2D块循环分布”在处理器之间分配块，搜索后我得到以下伪代码：例如，具有（Nx，Ny）虚拟拓扑的p处理器，p=NxNy矩阵a[n][n]，n=rx*Nx=ry*nya[rxI:rx*（i+1）-1，J:Ny:n-1]，I=0，…，rx-1，J=0，…，ry-1，是一个二维分解，x方向的块分布，y方向的循环分布矩阵a[n][n]，n=rx*Nx=ry*Nyhello@VladimirF，在你的代码中，。为什么在上次打印中你又去等于trans-to-arr数组？因为arr是原始数组？