c - 创建鬼区 MPI 的正确方法 [光晕]-6ren

c - 创建鬼区 MPI 的正确方法 [光晕]

转载作者：行者123 更新时间：2023-12-04 00:07:08

晚安

我正在参加并行编程类(class)。老师给了我们一个涉及模板计算的域划分的作业。对于这种类型的计算(有限差分)，并行化代码的最常见方法是划分域并创建一些幽灵区域(光晕)。

为了更好地理解在 MPI 中创建幻影区域，我编写了这个简单的示例，初始化了一些内部值 = 123 和边界值 88 的数组。在所有通信结束时，所有幻影值应保持 8。在一个节点中，我'得到 123 个值。

连续剧(无鬼):

   123 - 123 - ... - 123 - 123

两个分区:

   123 - 123 - ... - 88  |||  88 - ... - 123 - 123

三个分区:

   123 - 123 - ... - 88  |||  88 - ... - 123 - 123 - 88 ||| 88 - ... - 123 - 123

除了这个错误，这里的主要问题是关于创建和维护更新的幽灵区域的正确方法。除了我凌乱的 if(myid == .... else if( myid = ... else 类型的实现之外，还有更干净的解决方案吗？人们通常如何实现这种并行性？

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

int WhichSize(int mpiId, int numProc, int tam);

int main(int argc, char *argv[]){

    int i;
    int localSize;
    int numProc;
    int myid;

    int leftProc;
    int rightProc;

    int * myArray;
    int fullDomainSize = 16;

    MPI_Request request;

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


    // Lets get each partition size.
    localSize = WhichSize(myid, numProc, fullDomainSize);


    // Allocate arrays acording to proc number.
    if(numProc == 1){

        //printf("Allocating Array for serial usage\n");
        myArray = (int*)malloc(localSize*sizeof(int));

    } else if(numProc == 2) {

        //printf("Allocating Array for 2 proc usage\n");
        myArray = (int*)malloc((localSize+ 1)*sizeof(int));

    } else if(numProc > 2) {

        if (myid == 0 || myid == numProc - 1){

            //printf("Allocating array for boundary nodes usage\n");
            myArray = (int*)malloc((localSize+ 1)*sizeof(int));

        } else {

            //printf("Allocating array for inner nodes usage\n");
            myArray = (int*)malloc((localSize+ 2)*sizeof(int));

        }

    }


    // Now we will fill the arrays with a dummy value 123. For the
    // boundaries (ghosts) we will fill than with 80. Just to differe
    // ntiate.

    if(numProc == 1){

        //printf("----------------------------------------\n");
        //printf("Filling the serial array with values... \n");

        for (i = 0; i<localSize; i++){
            myArray[i] = 123;
        }

    } else if(numProc == 2) {

        ////printf("------------------------------------------------\n");
        //printf("Filling array for two proc usage with values... \n");

        for (i = 0; i<localSize; i++){
            myArray[i] = 123;
        }

        // ghost.
        myArray[localSize+1] = 8;

    } else if(numProc > 2) {

        if (myid == 0 || myid == numProc - 1){

            //printf("--------------------------------------------------\n");
            //printf("Filling boundary node arrays usage with values... \n");

            for (i = 0; i<localSize; i++){
                myArray[i] = 123;
            }

            // ghosts.
            myArray[localSize+1] = 8;

        } else {

            //printf("--------------------------------------------------\n");
            //printf("Filling inner node arrays usage with values... \n");

            for (i = 0; i<localSize; i++){
                myArray[i] = 123;
            }

            // ghosts.
            myArray[localSize+1] = 8;
            myArray[0] = 8;

        }

    }


    // Now lets comunicate the ghosts with MPI_Sendrecv().

    if(numProc == 1){

        //printf("Serial usage, no ghost to comunicate \n");

    } else if(numProc == 2) {

        if (myid == 0){

            //printf("Sending ghost value from proc %d to %d\n", myid, myid + 1);
            MPI_Isend(&myArray[localSize+1],
                      1,
                      MPI_INT,
                      1,
                      12345,
                      MPI_COMM_WORLD,
                      &request);

        } else if (myid == 1) {

            //printf("Receiving ghost value from proc %d to %d\n", myid-1, myid);
            MPI_Irecv(&myArray[localSize+1],
                      1,
                      MPI_INT,
                      0,
                      12345,
                      MPI_COMM_WORLD,
                      &request);
        }


    } else if(numProc > 2) {

        if (myid == 0){

            rightProc = myid + 1;

            if (myid == 0){

                //printf("-------------------------------\n");
                //printf("Communicating Boundary ghosts !\n");
                //printf("-------------------------------\n");

                //printf("Sending ghost value from proc %d to %d\n", myid, myid + 1);
                MPI_Isend(&myArray[localSize+1],
                          1,
                          MPI_INT,
                          rightProc,
                          12345,
                          MPI_COMM_WORLD,
                          &request);

            } else if (myid == rightProc) {

                //printf("Receiving ghost value from proc %d to %d\n", myid-1, myid);
                MPI_Irecv(&myArray[localSize+1],
                          1,
                          MPI_INT,
                          0,
                          12345,
                          MPI_COMM_WORLD,
                          &request);
            } 

        } else if (myid == numProc - 1) {

            leftProc  = myid - 1;

            if (myid == numProc - 1){

                //printf("-------------------------------\n");
                //printf("Communicating Boundary ghosts !\n");
                //printf("-------------------------------\n");

                ////printf("Sending ghost value from proc %d to %d\n", myid, myid + 1);
                MPI_Isend(&myArray[localSize+1],
                          1,
                          MPI_INT,
                          leftProc,
                          12345,
                          MPI_COMM_WORLD,
                          &request);

            } else if (myid == leftProc) {

                rightProc = myid + 1;

                //printf("Receiving ghost value from proc %d to %d\n", myid-1, myid);
                MPI_Irecv(&myArray[localSize+1],
                          1,
                          MPI_INT,
                          rightProc,
                          12345,
                          MPI_COMM_WORLD,
                          &request);
            } 

        } else {

                //printf("-------------------------------\n");
                //printf("Communicating Inner ghosts baby\n");
                //printf("-------------------------------\n");

                leftProc  = myid - 1;
                rightProc = myid + 1;

                // Communicate tail ghost.
                if (myid == leftProc) {
                    MPI_Isend(&myArray[localSize+1],
                              1,
                              MPI_INT,
                              rightProc,
                              12345,
                              MPI_COMM_WORLD,
                              &request);

                } else if (myid == rightProc){
                    MPI_Irecv(&myArray[localSize+1],
                              1,
                              MPI_INT,
                              leftProc,
                              12345,
                              MPI_COMM_WORLD,
                              &request);
                }

                // Communicate head ghost.
                if (myid == leftProc) {
                    MPI_Isend(&myArray[0],
                              1,
                              MPI_INT,
                              rightProc,
                              12345,
                              MPI_COMM_WORLD,
                              &request);

                } else if (myid == rightProc){
                    MPI_Irecv(&myArray[0],
                              1,
                              MPI_INT,
                              leftProc,
                              12345,
                              MPI_COMM_WORLD,
                              &request);
                }
        }
    }


    // Now I Want to see if the ghosts are in place !.

    if (myid == 0){
        printf("The ghost value is: %d\n", myArray[localSize + 1]);
    } else if (myid == numProc - 1){
        printf("The ghost value is: %d\n", myArray[0]);
    } else {
        printf("The head ghost is: %d\n", myArray[0]);
        printf("The tail ghost is: %d\n", myArray[localSize + 1]);
    }


    MPI_Finalize();

    exit(0);
}

int WhichSize(int mpiId, int numProc, int tam){

    double resto;
    int    tamLocal;

    tamLocal = tam / numProc;

    resto = tam - tamLocal*numProc;

    if (mpiId < resto) tamLocal = tamLocal + 1;


    return tamLocal;
}

谢谢你们!

最佳答案

可以使用笛卡尔虚拟拓扑和发送-接收操作在 MPI 中优雅地实现光晕。

首先，条件运算符中有大量与等级相关的逻辑会使代码难以阅读和理解。当代码是对称的时会更好，即当所有等级执行相同的代码时。可以使用 MPI_PROC_NULL 空等级来处理极端情况 - 发送到该等级或从该等级接收会导致无操作。因此，这样做就足够了:

// Compute the rank of the left neighbour
leftProc = myid - 1;
if (leftProc < 0) leftProc = MPI_PROC_NULL;
// Compute the rank of the right neighbour
rightProc = myid + 1;
if (rightProc >= numProc) rightProc = MPI_PROC_NULL;

// Halo exchange in forward direction
MPI_Sendrecv(&myArray[localSize], 1, MPI_INT, rightProc, 0,   // send last element to the right
             &myArray[0], 1, MPI_INT, leftProc, 0,            // receive into left halo
             MPI_COMM_WORLD);
// Halo exchange in reverse direction
MPI_Sendrecv(&myArray[1], 1, MPI_INT, leftProc, 0,            // send first element to the left
             &myArray[localSize+1], 1, MPI_INT, rightProc, 0, // receive into right halo
             MPI_COMM_WORLD);

该代码适用于任何等级，即使对于两端的等级 - 源或目标都是空等级，并且在相应方向上不会发生实际转移。它也适用于任意数量的 MPI 进程，从一个到多个。它要求所有等级的两边都有光环，包括那些并不真正需要它的(两个角落等级)。人们可以在那些虚拟光环中存储有用的东西，例如边界值(例如在求解偏微分方程时)，或者干脆忍受通常可以忽略不计的内存浪费。

在您的代码中，您错误地使用了非阻塞操作。这些很棘手，需要小心。 MPI_Sendrecv 可以而且应该被使用。它同时执行发送和接收操作，从而防止死锁(只要每次发送都有匹配的接收)。

如果域是周期性的，那么秩计算逻辑就变得简单了:

// Compute the rank of the left neighbour
leftProc = (myid - 1 + numProc) % numProc;
// Compute the rank of the right neighbour
rightProc = (myid + 1) % numProc;

可以创建笛卡尔虚拟拓扑，然后使用 MPI_Cart_shift 来查找两个邻居的排名，而不是进行算术运算:

// Create a non-periodic 1-D Cartesian topology
int dims[1] = { numProc };
int periods[1] = { 0 };   // 0 - non-periodic, 1 - periodic
MPI_Comm cart_comm;
MPI_Cart_create(MPI_COMM_WORLD, 1, dims, periods, 1, &cart_comm);

// Find the two neighbours
MPI_Cart_shift(cart_comm, 0, 1, &leftProc, &rightProc);

光环交换的代码保持不变，唯一的区别是 cart_comm 应该替换 MPI_COMM_WORLD。 MPI_Cart_shift 自动处理极端情况，并在适当时返回 MPI_PROC_NULL。该方法的优点是您可以通过简单地翻转 periods[] 数组中的值轻松地在非周期域和周期域之间切换。

光环必须根据需要经常更新，这取决于算法。对于大多数迭代方案，更新必须在每次迭代开始时发生。可以通过引入多级光晕并使用外层的值来计算内层的值来降低通信频率。

总而言之，您的 main 函数可以简化为(不使用笛卡尔拓扑):

int main(int argc, char *argv[]){

    int i;
    int localSize;
    int numProc;
    int myid;

    int leftProc;
    int rightProc;

    int * myArray;
    int fullDomainSize = 16;

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

    // Compute neighbouring ranks
    rightProc = myid + 1;
    if (rightProc >= numProc) rightProc = MPI_PROC_NULL;
    leftProc = myid - 1;
    if (leftProc < 0) leftProc = MPI_PROC_NULL;

    // Lets get each partition size.
    localSize = WhichSize(myid, numProc, fullDomainSize);

    // Allocate arrays.
    myArray = (int*)malloc((localSize+ 2)*sizeof(int));

    // Now we will fill the arrays with a dummy value 123. For the
    // boundaries (ghosts) we will fill than with 80. Just to differe
    // ntiate.

    //printf("--------------------------------------------------\n");
    //printf("Filling node arrays usage with values... \n");

    for (i = 1; i<localSize; i++){
        myArray[i] = 123;
    }

    // ghosts.
    myArray[localSize+1] = 8;
    myArray[0] = 8;

    //printf("-------------------------------\n");
    //printf("Communicating Boundary ghosts !\n");
    //printf("-------------------------------\n");

    //printf("Sending ghost value to the right\n");
    MPI_Sendrecv(&myArray[localSize], 1, MPI_INT, rightProc, 12345,
                 &myArray[0], 1, MPI_INT, leftProc, 12345,
                 MPI_COMM_WORLD);

    //printf("Sending ghost value to the left\n");
    MPI_Sendrecv(&myArray[1], 1, MPI_INT, leftProc, 12345,
                 &myArray[localSize+1], 1, MPI_INT, rightProc, 12345,
                 MPI_COMM_WORLD);

    // Now I Want to see if the ghosts are in place !.

    printf("[%d] The head ghost is: %d\n", myid, myArray[0]);
    printf("[%d] The tail ghost is: %d\n", myid, myArray[localSize + 1]);

    MPI_Finalize();

    return 0;
}

关于c - 创建鬼区 MPI 的正确方法 [光晕]，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36960455/

文章推荐：生成_auth_cookie时Wordpress json api错误

文章推荐： Blackberry - 具有不同 ID 的可点击 ListView

文章推荐： class - UML 类图中关联箭头的方向

文章推荐： django - 出现错误后如何重做迁移？

c++ - C c;之间有什么区别吗？和 C c = C();?
#include using namespace std; class C{ private: int value; public: C(){ value = 0;
c++ - C 风格字符串差异 : C/C++
这个问题已经有答案了: What is the difference between char a[] = ?string?; and char *p = ?string?;? (8 个回答) 已关闭
c++ - c\c++ 转换为 C#
关闭。此题需要details or clarity 。目前不接受答案。想要改进这个问题吗？通过 editing this post 添加详细信息并澄清问题. 已关闭 7 年前。此帖子已于 8 个月
c# - C、C++、C# 的功能测试工具
除了调试之外，是否有任何针对 c、c++ 或 c# 的测试工具，其工作原理类似于将独立函数复制粘贴到某个文本框，然后在其他文本框中输入参数？最佳答案也许您会考虑单元测试。我推荐你谷歌测试和谷歌模拟
c# - C/C++/C# 在监视器上设置窗口位置
我想在第二台显示器中移动一个窗口 (HWND)。问题是我尝试了很多方法，例如将分辨率加倍或输入负值，但它永远无法将窗口放在我的第二台显示器上。关于如何在 C/C++/c# 中执行此操作的任何线索最
c# - C/C++/C#中的DES实现
我正在寻找 C/C++/C## 中不同类型 DES 的现有实现。我的运行平台是Windows XP/Vista/7。我正在尝试编写一个 C# 程序，它将使用 DES 算法进行加密和解密。我需要一些实
c# - 在条件中使用赋值是否安全？ C/C++、C#
很难说出这里要问什么。这个问题模棱两可、含糊不清、不完整、过于宽泛或夸夸其谈，无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开，visit the help center . 关闭 1
c++ - C/C++/C# 强制窗口在最上面
有没有办法强制将另一个窗口置于顶部？不是应用程序的窗口，而是另一个已经在系统上运行的窗口。 (Windows, C/C++/C#) 最佳答案 SetWindowPos(that_window_ha
c# - 套接字服务器应用程序的选择 : C/C++ or C#
假设您可以在 C/C++ 或 Csharp 之间做出选择，并且您打算在 Windows 和 Linux 服务器上运行同一服务器的多个实例，那么构建套接字服务器应用程序的最明智选择是什么？最佳答案如
c++ - C/C++ 运行时库和 C/C++ 标准库的区别
你们能告诉我它们之间的区别吗？顺便问一下，有什么叫C++库或C库的吗？最佳答案 C++ 标准库和 C 标准库是 C++ 和 C 标准定义的库，提供给 C++ 和 C 程序使用。那是那些词的共同
c++ - &C::c 和 &(C::c) 有什么区别？
下面的测试代码，我将输出信息放在注释中。我使用的是 gcc 4.8.5 和 Centos 7.2。 #include #include class C { public:
c++ - 什么 C++(通用 (c/c++) 与 (通用 c)/c++ )
很难说出这里问的是什么。这个问题是含糊的、模糊的、不完整的、过于宽泛的或修辞性的，无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开它，visit the help center 。已关
c# - 通过网络在 C/C++ 服务器、C/C++ 和 C# 客户端之间发送数据结构
我的客户将使用名为 annoucement 的结构/类与客户通信。我想我会用 C++ 编写服务器。会有很多不同的类继承annoucement。我的问题是通过网络将这些类发送给客户端我想也许我应该使用
c# - C/C++ - 如何将 Buffer.BlockCopy (C#) 转换为 C/C++
我在 C# 中有以下函数: public Matrix ConcatDescriptors(IList> descriptors) { int cols = descriptors[0].Co
c++ - C/C++ - 对其他人隐藏 C 或 C++ 函数代码
我有一个项目要编写一个函数来对某些数据执行某些操作。我可以用 C/C++ 编写代码，但我不想与雇主共享该函数的代码。相反，我只想让他有权在他自己的代码中调用该函数。是否可以？我想到了这两种方法 - 在
c# - 在托管代码(C++、C、C++/CLI、C#)中使用非托管代码时处理错误
我使用的是编写糟糕的第 3 方 (C/C++) Api。我从托管代码(C++/CLI)中使用它。有时会出现“访问冲突错误”。这使整个应用程序崩溃。我知道我无法处理这些错误[如果指针访问非法内存位置等，
c# - C#、C/C++ 或 Objective-C 中的眼动追踪库
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。我们不允许提问寻求书籍、工具、软件库等的推荐。您可以编辑问题，以便用事实和引用来回答。关闭 7 年前。
c++ - C/C++/Objective-C 文本识别库
已关闭。此问题不符合Stack Overflow guidelines 。目前不接受答案。要求我们推荐或查找工具、库或最喜欢的场外资源的问题对于 Stack Overflow 来说是偏离主题的，因为
c# - 将 C/C++ 函数导入 C#
我有一些 C 代码，将使用 P/Invoke 从 C# 调用。我正在尝试为这个 C 函数定义一个 C# 等效项。 SomeData* DoSomething(); struct SomeData {
c - C语言中 "c -= --c - c++;"的结果应该是什么？
这个问题已经有答案了: Why are these constructs using pre and post-increment undefined behavior? (14 个回答) 已关闭 6

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - 创建鬼区 MPI 的正确方法 [光晕]