C++ (Cpp) MPIX_Comm_split_typeの例

コード例 #1

int OSPU_Comm_split_node(MPI_Comm oldcomm, MPI_Comm * newcomm)
{
    int rc = MPI_SUCCESS;

#if MPI_VERSION >= 3

    rc = MPI_Comm_split_type(oldcomm, MPI_COMM_TYPE_SHARED, 0, MPI_INFO_NULL, newcomm);
    if (rc!=MPI_SUCCESS) return rc;

#elif defined(MPICH2) && (MPICH2_NUMVERSION>10500000)

    rc = MPIX_Comm_split_type(oldcomm, MPIX_COMM_TYPE_SHARED, 0, MPI_INFO_NULL, newcomm);
    if (rc!=MPI_SUCCESS) return rc;

#else

    /* This code was authored by Jim Dinan */

    char my_name[MPI_MAX_PROCESSOR_NAME];
    MPI_Comm node_comm = MPI_COMM_NULL;
    MPI_Comm parent_comm;
    int len;

    /* Dup so we don't leak communicators */
    rc = MPI_Comm_dup(oldcomm, &parent_comm);
    if (rc!=MPI_SUCCESS) return rc;

    rc = MPI_Get_processor_name(my_name, &len);
    if (rc!=MPI_SUCCESS) return rc;

    while (node_comm == MPI_COMM_NULL)
    {
        char root_name[MPI_MAX_PROCESSOR_NAME];
        int  rank;
        MPI_Comm old_parent;

        rc = MPI_Comm_rank(parent_comm, &rank);
        if (rc!=MPI_SUCCESS) return rc;

        if (rank == 0)
        {
            rc = MPI_Bcast(my_name, MPI_MAX_PROCESSOR_NAME, MPI_CHAR, 0, parent_comm);
            if (rc!=MPI_SUCCESS) return rc;
            strncpy(root_name, my_name, MPI_MAX_PROCESSOR_NAME);
        } 
        else 
        {
            rc = MPI_Bcast(root_name, MPI_MAX_PROCESSOR_NAME, MPI_CHAR, 0, parent_comm);
            if (rc!=MPI_SUCCESS) return rc;
        }

        old_parent = parent_comm;

        if (strncmp(my_name, root_name, MPI_MAX_PROCESSOR_NAME) == 0)
        {
            /* My group splits off, I'm done after this */
            rc = MPI_Comm_split(parent_comm, 1, rank, &node_comm);
            if (rc!=MPI_SUCCESS) return rc;
        }
        else
        {
            /* My group keeps going, separate from the others */
            rc = MPI_Comm_split(parent_comm, 0, rank, &parent_comm);
            if (rc!=MPI_SUCCESS) return rc;
        }

        /* Old parent is no longer needed */
        rc = MPI_Comm_free(&old_parent);
        if (rc!=MPI_SUCCESS) return rc;
    }

    *newcomm = node_comm;

#endif

    return rc = MPI_SUCCESS;
}

コード例 #2

ファイル: win_shared_noncontig.c プロジェクト: jimmycao/mpi-test

int main(int argc, char **argv) {
    int      i, j, rank, nproc;
    int      shm_rank, shm_nproc;
    MPI_Info alloc_shared_info;
    int      errors = 0, all_errors = 0;
    int      disp_unit;
    int     *my_base;
    MPI_Win  shm_win;
    MPI_Comm shm_comm;

    MPI_Init(&argc, &argv);

    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &nproc);

    MPI_Info_create(&alloc_shared_info);
    MPI_Info_set(alloc_shared_info, "alloc_shared_noncontig", "true");

#ifdef TEST_MPI3_ROUTINES

    MPIX_Comm_split_type(MPI_COMM_WORLD, MPIX_COMM_TYPE_SHARED, rank, MPI_INFO_NULL, &shm_comm);

    MPI_Comm_rank(shm_comm, &shm_rank);
    MPI_Comm_size(shm_comm, &shm_nproc);

    /* Allocate ELEM_PER_PROC integers for each process */
    MPIX_Win_allocate_shared(sizeof(int)*ELEM_PER_PROC, sizeof(int), alloc_shared_info, 
                             shm_comm, &my_base, &shm_win);

    MPIX_Win_lock_all(MPI_MODE_NOCHECK, shm_win);

    /* Write to all my data */
    for (i = 0; i < ELEM_PER_PROC; i++) {
        my_base[i] = i;
    }

    MPIX_Win_sync(shm_win);
    MPI_Barrier(shm_comm);
    MPIX_Win_sync(shm_win);

    /* Read and verify everyone's data */
    for (i = 0; i < shm_nproc; i++) {
        int      *base;
        MPI_Aint  size;

        MPIX_Win_shared_query(shm_win, i, &size, &disp_unit, &base);
        assert(size == ELEM_PER_PROC * sizeof(int));

        for (j = 0; j < ELEM_PER_PROC; j++) {
            if ( base[j] != j ) {
                errors++;
                printf("%d -- Got %d at rank %d index %d, expected %d\n", shm_rank, 
                       base[j], i, j, j);
            }
        }
    }

    MPIX_Win_unlock_all(shm_win);
    MPI_Win_free(&shm_win);
    MPI_Comm_free(&shm_comm);

#endif /* TEST_MPI3_ROUTINES */

    MPI_Info_free(&alloc_shared_info);

    MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);

    if (rank == 0 && all_errors == 0)
        printf(" No Errors\n");

    MPI_Finalize();

    return 0;
}