Question

我想使用集体MPI I / O写出二进制文件。我的计划是创建一个类似于

的MPI派生类型

struct soln_dynamic_t
{
    int int_data[2];
    double *u;   /* Length constant for all instances of this struct */
};

然后，每个处理器根据派生类型创建一个视图，并写入视图。

我认为这一切都适用于*u替换为u[10]的情况（请参阅下面的完整代码），但最终，我希望{的动态长度数组{1}}。（如果重要的话，对于任何运行，u的所有实例的长度都是固定的，但在编译时不知道。）

处理此问题的最佳方法是什么？

我已阅读几篇关于我无法使用soln_dynamic_t的帖子直接作为MPI结构。问题是不能保证处理器在soln_dynamic_t和u[0]之间具有相同的偏移量。（是吗？）

另一方面，结构

int_data[0]

有效，因为各处理器的偏移量保证相同。

我考虑了几种方法：

根据手动定义的偏移等创建视图，而不是使用派生类型。
将MPI结构基于另一个MPI类型，即``* u`的连续类型（是允许的？）

我猜我必须有一个标准的方法来做到这一点。任何建议都会非常有用。

关于这个问题的其他一些帖子很有帮助，尽管它们主要处理通信而不是文件I / O.

这是完整的代码::

struct soln_static_t
{
    int int_data[2];
    double u[10];     /* fixed at compile time */
};

Answer 1

由于u类型的soln_dynamic_t数组的大小在运行时已知，并且在此之后不会更改，我建议采用其他方法。

基本上，您将所有连续的数据存储在内存中：

typedef struct
{
    int int_data[2];
    double u[];  /* Make this a dynamic length (but fixed) */
} soln_dynamic_t;

然后你必须手动分配这个结构

soln_dynamic_t * alloc_soln(int nsize, int count) {
    return (soln_dynamic_t *)calloc(offsetof(soln_dynamic_t, u)+nsize*sizeof(double), count);
}

请注意，您无法直接访问soln_dynamic_t数组，因为在编译时大小未知。相反，您必须手动计算指针。

soln_dynamic_t *p = alloc_soln(10, 2);
p[0].int_data[0] = 1;  // OK
p[0].u[0] = 2;         // OK
p[1].int_data[0] = 3;  // KO ! since sizeof(soln_dynamic_t) is unknown at compile time.

以下是程序的完整重写版本

#include <mpi.h>
#include <malloc.h>

typedef struct 
{
    int int_data[2];
    double u[];  /* Make this a dynamic length (but fixed) */
} soln_dynamic_t;


void build_soln_type(int n, MPI_Datatype *soln_t)
{
    int block_lengths[2] = {2,n};
    MPI_Datatype typelist[2] = {MPI_INT, MPI_DOUBLE};
    MPI_Aint disp[2];

    disp[0] = offsetof(soln_dynamic_t, int_data);
    disp[1] = offsetof(soln_dynamic_t, u);

    MPI_Datatype tmp_type;
    MPI_Type_create_struct(2,block_lengths,disp,typelist,&tmp_type);

    MPI_Aint extent;
    extent = offsetof(soln_dynamic_t, u) + block_lengths[1]*sizeof(double);
    MPI_Type_create_resized(tmp_type, 0, extent, soln_t);
    MPI_Type_free(&tmp_type);
    MPI_Type_commit(soln_t);
}

soln_dynamic_t * alloc_soln(int nsize, int count) {
    return (soln_dynamic_t *)calloc(offsetof(soln_dynamic_t, u) + nsize*sizeof(double), count);
}

int main(int argc, char** argv)
{
    MPI_File   file;
    int globalsize, localsize, starts, order;

    MPI_Datatype localarray, soln_t;
    int rank, nprocs, nsize = 10;  /* must match size in struct above */

    /* --- Initialize MPI */
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);

    /* --- Set up data to write out */
    soln_dynamic_t *data = alloc_soln(nsize,1);
    data->int_data[0] = nsize;
    data->int_data[1] = rank;
    data->u[0] = 3.14159;  /* To check that data is written as expected */
    build_soln_type(nsize, &soln_t);

    MPI_File_open(MPI_COMM_WORLD, "bin2.out", 
                  MPI_MODE_CREATE|MPI_MODE_WRONLY,
                  MPI_INFO_NULL, &file);

    /* --- Create file view for this processor */
    globalsize = nprocs;  
    localsize = 1;
    starts = rank;
    order = MPI_ORDER_C;

    MPI_Type_create_subarray(1, &globalsize, &localsize, &starts, order, 
                             soln_t, &localarray);
    MPI_Type_commit(&localarray);

    MPI_File_set_view(file, 0, soln_t, localarray, 
                           "native", MPI_INFO_NULL);

    /* --- Write data into view */
    MPI_File_write_all(file, data, 1, soln_t, MPI_STATUS_IGNORE);

    /* --- Clean up */
    MPI_File_close(&file);

    MPI_Type_free(&localarray);
    MPI_Type_free(&soln_t);

    MPI_Finalize();
    return 0;
}

创建动态大小的MPI文件视图

1 个答案: