teshsuite/smpi/mpich3-test/group/gtranks.c

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *  (C) 2001 by Argonne National Laboratory.
   4  *      See COPYRIGHT in top-level directory.
   5  */
   6 #include "mpi.h"
   7 #include <stdio.h>
   8 #include "mpitest.h"
   9
  10 #define MAX_WORLD_SIZE 1024
  11
  12 int main(int argc, char *argv[])
  13 {
  14     int errs = 0;
  15     int ranks[MAX_WORLD_SIZE], ranksout[MAX_WORLD_SIZE], ranksin[MAX_WORLD_SIZE];
  16     int range[1][3];
  17     MPI_Group gworld, gself, ngroup, galt;
  18     MPI_Comm comm;
  19     int rank, size, i, nelms;
  20
  21     MTest_Init(&argc, &argv);
  22
  23     MPI_Comm_group(MPI_COMM_SELF, &gself);
  24
  25     comm = MPI_COMM_WORLD;
  26
  27     MPI_Comm_size(comm, &size);
  28     MPI_Comm_rank(comm, &rank);
  29
  30     if (size > MAX_WORLD_SIZE) {
  31         fprintf(stderr,
  32                 "This test requires a comm world with no more than %d processes\n", MAX_WORLD_SIZE);
  33         MPI_Abort(MPI_COMM_WORLD, 1);
  34     }
  35     if (size < 4) {
  36         fprintf(stderr, "This test requiers at least 4 processes\n");
  37         MPI_Abort(MPI_COMM_WORLD, 1);
  38     }
  39
  40     MPI_Comm_group(comm, &gworld);
  41     for (i = 0; i < size; i++) {
  42         ranks[i] = i;
  43         ranksout[i] = -1;
  44     }
  45     /* Try translating ranks from comm world compared against
  46      * comm self, so most will be UNDEFINED */
  47     MPI_Group_translate_ranks(gworld, size, ranks, gself, ranksout);
  48
  49     for (i = 0; i < size; i++) {
  50         if (i == rank) {
  51             if (ranksout[i] != 0) {
  52                 printf("[%d] Rank %d is %d but should be 0\n", rank, i, ranksout[i]);
  53                 errs++;
  54             }
  55         }
  56         else {
  57             if (ranksout[i] != MPI_UNDEFINED) {
  58                 printf("[%d] Rank %d is %d but should be undefined\n", rank, i, ranksout[i]);
  59                 errs++;
  60             }
  61         }
  62     }
  63
  64     /* MPI-2 Errata requires that MPI_PROC_NULL is mapped to MPI_PROC_NULL */
  65     ranks[0] = MPI_PROC_NULL;
  66     ranks[1] = 1;
  67     ranks[2] = rank;
  68     ranks[3] = MPI_PROC_NULL;
  69     for (i = 0; i < 4; i++)
  70         ranksout[i] = -1;
  71
  72     MPI_Group_translate_ranks(gworld, 4, ranks, gself, ranksout);
  73     if (ranksout[0] != MPI_PROC_NULL) {
  74         printf("[%d] Rank[0] should be MPI_PROC_NULL but is %d\n", rank, ranksout[0]);
  75         errs++;
  76     }
  77     if (rank != 1 && ranksout[1] != MPI_UNDEFINED) {
  78         printf("[%d] Rank[1] should be MPI_UNDEFINED but is %d\n", rank, ranksout[1]);
  79         errs++;
  80     }
  81     if (rank == 1 && ranksout[1] != 0) {
  82         printf("[%d] Rank[1] should be 0 but is %d\n", rank, ranksout[1]);
  83         errs++;
  84     }
  85     if (ranksout[2] != 0) {
  86         printf("[%d] Rank[2] should be 0 but is %d\n", rank, ranksout[2]);
  87         errs++;
  88     }
  89     if (ranksout[3] != MPI_PROC_NULL) {
  90         printf("[%d] Rank[3] should be MPI_PROC_NULL but is %d\n", rank, ranksout[3]);
  91         errs++;
  92     }
  93
  94     MPI_Group_free(&gself);
  95
  96     /* Now, try comparing small groups against larger groups, and use groups
  97      * with irregular members (to bypass optimizations in group_translate_ranks
  98      * for simple groups)
  99      */
 100     nelms = 0;
 101     ranks[nelms++] = size - 2;
 102     ranks[nelms++] = 0;
 103     if (rank != 0 && rank != size - 2) {
 104         ranks[nelms++] = rank;
 105     }
 106
 107     MPI_Group_incl(gworld, nelms, ranks, &ngroup);
 108
 109     for (i = 0; i < nelms; i++)
 110         ranksout[i] = -1;
 111     ranksin[0] = 1;
 112     ranksin[1] = 0;
 113     ranksin[2] = MPI_PROC_NULL;
 114     ranksin[3] = 2;
 115     MPI_Group_translate_ranks(ngroup, nelms + 1, ranksin, gworld, ranksout);
 116     for (i = 0; i < nelms + 1; i++) {
 117         if (ranksin[i] == MPI_PROC_NULL) {
 118             if (ranksout[i] != MPI_PROC_NULL) {
 119                 fprintf(stderr, "Input rank for proc_null but output was %d\n", ranksout[i]);
 120                 errs++;
 121             }
 122         }
 123         else if (ranksout[i] != ranks[ranksin[i]]) {
 124             fprintf(stderr, "Expected ranksout[%d] = %d but found %d\n",
 125                     i, ranks[ranksin[i]], ranksout[i]);
 126             errs++;
 127         }
 128     }
 129
 130     range[0][0] = size - 1;
 131     range[0][1] = 0;
 132     range[0][2] = -1;
 133     MPI_Group_range_incl(gworld, 1, range, &galt);
 134     for (i = 0; i < nelms + 1; i++)
 135         ranksout[i] = -1;
 136     MPI_Group_translate_ranks(ngroup, nelms + 1, ranksin, galt, ranksout);
 137     for (i = 0; i < nelms + 1; i++) {
 138         if (ranksin[i] == MPI_PROC_NULL) {
 139             if (ranksout[i] != MPI_PROC_NULL) {
 140                 fprintf(stderr, "Input rank for proc_null but output was %d\n", ranksout[i]);
 141                 errs++;
 142             }
 143         }
 144         else if (ranksout[i] != (size - 1) - ranks[ranksin[i]]) {
 145             fprintf(stderr, "Expected ranksout[%d] = %d but found %d\n",
 146                     i, (size - 1) - ranks[ranksin[i]], ranksout[i]);
 147             errs++;
 148         }
 149     }
 150
 151
 152     MPI_Group_free(&gworld);
 153     MPI_Group_free(&galt);
 154     MPI_Group_free(&ngroup);
 155
 156     MTest_Finalize(errs);
 157     MPI_Finalize();
 158
 159     return 0;
 160 }