teshsuite/smpi/mpich3-test/rma/rmazero.c

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *
   4  *  (C) 2010 by Argonne National Laboratory.
   5  *      See COPYRIGHT in top-level directory.
   6  */
   7 #include "mpi.h"
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include "mpitest.h"
  11
  12 #define TARGET 0
  13
  14 /* Test the given operation within a Fence epoch */
  15 #define TEST_FENCE_OP(op_name_, fcn_call_)                              \
  16     do {                                                                \
  17         err = fcn_call_                                                 \
  18         if (err) {                                                      \
  19             errs++;                                                     \
  20             if (errs < 10) {                                            \
  21                 MTestPrintErrorMsg("Zero-byte op " op_name_, err);    \
  22             }                                                           \
  23         }                                                               \
  24         err = MPI_Win_fence(0, win);                                  \
  25         if (err) {                                                      \
  26             errs++;                                                     \
  27             if (errs < 10) {                                            \
  28                 MTestPrintErrorMsg("Fence after " op_name_, err);     \
  29             }                                                           \
  30         }                                                               \
  31     } while (0)
  32
  33
  34 /* Test the given operation within a passive target epoch */
  35 #define TEST_PT_OP(op_name_, fcn_call_)                                 \
  36     do {                                                                \
  37         err = MPI_Win_lock(MPI_LOCK_EXCLUSIVE, TARGET, 0, win);         \
  38         if (err) {                                                      \
  39             errs++;                                                     \
  40             if (errs < 10) {                                            \
  41                 MTestPrintErrorMsg("Lock before" op_name_, err);      \
  42             }                                                           \
  43         }                                                               \
  44         err = fcn_call_                                                 \
  45         if (err) {                                                      \
  46             errs++;                                                     \
  47             if (errs < 10) {                                            \
  48                 MTestPrintErrorMsg("Zero-byte op " op_name_, err);    \
  49             }                                                           \
  50         }                                                               \
  51         err = MPI_Win_unlock(TARGET, win);                            \
  52         if (err) {                                                      \
  53             errs++;                                                     \
  54             if (errs < 10) {                                            \
  55                 MTestPrintErrorMsg("Unlock after " op_name_, err);    \
  56             }                                                           \
  57         }                                                               \
  58     } while (0)
  59
  60
  61 /* Test the given request-based operation within a passive target epoch */
  62 #define TEST_REQ_OP(op_name_, req_, fcn_call_)                          \
  63     do {                                                                \
  64         err = MPI_Win_lock(MPI_LOCK_EXCLUSIVE, TARGET, 0, win);         \
  65         if (err) {                                                      \
  66             errs++;                                                     \
  67             if (errs < 10) {                                            \
  68                 MTestPrintErrorMsg("Lock before" op_name_, err);      \
  69             }                                                           \
  70         }                                                               \
  71         err = fcn_call_                                                 \
  72         if (err) {                                                      \
  73             errs++;                                                     \
  74             if (errs < 10) {                                            \
  75                 MTestPrintErrorMsg("Zero-byte op " op_name_, err);    \
  76             }                                                           \
  77         }                                                               \
  78         err = MPI_Win_unlock(TARGET, win);                            \
  79         if (err) {                                                      \
  80             errs++;                                                     \
  81             if (errs < 10) {                                            \
  82                 MTestPrintErrorMsg("Unlock after " op_name_, err);    \
  83             }                                                           \
  84         }                                                               \
  85         err = MPI_Wait(&req_, MPI_STATUS_IGNORE);                     \
  86         if (err) {                                                      \
  87             errs++;                                                     \
  88             if (errs < 10) {                                            \
  89                 MTestPrintErrorMsg("Wait after " op_name_, err);      \
  90             }                                                           \
  91         }                                                               \
  92     } while (0)
  93
  94 /*
  95 static char MTEST_Descrip[] = "Test handling of zero-byte transfers";
  96 */
  97
  98 int main(int argc, char *argv[])
  99 {
 100     int errs = 0, err;
 101     int rank, size;
 102     int *buf, bufsize;
 103     int *result;
 104     int *rmabuf, rsize, rcount;
 105     MPI_Comm comm;
 106     MPI_Win win;
 107     MPI_Request req;
 108     MPI_Datatype derived_dtp;
 109
 110     MTest_Init(&argc, &argv);
 111
 112     bufsize = 256 * sizeof(int);
 113     buf = (int *) malloc(bufsize);
 114     if (!buf) {
 115         fprintf(stderr, "Unable to allocated %d bytes\n", bufsize);
 116         MPI_Abort(MPI_COMM_WORLD, 1);
 117     }
 118     result = (int *) malloc(bufsize);
 119     if (!result) {
 120         fprintf(stderr, "Unable to allocated %d bytes\n", bufsize);
 121         MPI_Abort(MPI_COMM_WORLD, 1);
 122     }
 123     rcount = 16;
 124     rsize = rcount * sizeof(int);
 125     rmabuf = (int *) malloc(rsize);
 126     if (!rmabuf) {
 127         fprintf(stderr, "Unable to allocated %d bytes\n", rsize);
 128         MPI_Abort(MPI_COMM_WORLD, 1);
 129     }
 130
 131     MPI_Type_contiguous(2, MPI_INT, &derived_dtp);
 132     MPI_Type_commit(&derived_dtp);
 133
 134     /* The following loop is used to run through a series of communicators
 135      * that are subsets of MPI_COMM_WORLD, of size 1 or greater. */
 136     while (MTestGetIntracommGeneral(&comm, 1, 1)) {
 137         int count = 0;
 138
 139         if (comm == MPI_COMM_NULL)
 140             continue;
 141         /* Determine the sender and receiver */
 142         MPI_Comm_rank(comm, &rank);
 143         MPI_Comm_size(comm, &size);
 144
 145         MPI_Win_create(buf, bufsize, 2 * sizeof(int), MPI_INFO_NULL, comm, &win);
 146         /* To improve reporting of problems about operations, we
 147          * change the error handler to errors return */
 148         MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
 149
 150         /** TEST OPERATIONS USING ACTIVE TARGET (FENCE) SYNCHRONIZATION **/
 151         MPI_Win_fence(0, win);
 152
 153         TEST_FENCE_OP("Put", MPI_Put(rmabuf, count, MPI_INT, TARGET, 0, count, MPI_INT, win);
 154 );
 155
 156         TEST_FENCE_OP("Get", MPI_Get(rmabuf, count, MPI_INT, TARGET, 0, count, MPI_INT, win);
 157 );
 158         TEST_FENCE_OP("Accumulate",
 159                       MPI_Accumulate(rmabuf, count, MPI_INT, TARGET,
 160                                      0, count, MPI_INT, MPI_SUM, win);
 161 );
 162         TEST_FENCE_OP("Accumulate_derived",
 163                       MPI_Accumulate(rmabuf, count, derived_dtp, TARGET,
 164                                      0, count, derived_dtp, MPI_SUM, win);
 165 );
 166         TEST_FENCE_OP("Get accumulate",
 167                       MPI_Get_accumulate(rmabuf, count, MPI_INT, result,
 168                                          count, MPI_INT, TARGET, 0, count, MPI_INT, MPI_SUM, win);
 169 );
 170         /* Note: It's not possible to generate a zero-byte FOP or CAS */
 171
 172         /** TEST OPERATIONS USING PASSIVE TARGET SYNCHRONIZATION **/
 173
 174         TEST_PT_OP("Put", MPI_Put(rmabuf, count, MPI_INT, TARGET, 0, count, MPI_INT, win);
 175 );
 176         TEST_PT_OP("Get", MPI_Get(rmabuf, count, MPI_INT, TARGET, 0, count, MPI_INT, win);
 177 );
 178         TEST_PT_OP("Accumulate",
 179                    MPI_Accumulate(rmabuf, count, MPI_INT, TARGET, 0, count, MPI_INT, MPI_SUM, win);
 180 );
 181         TEST_PT_OP("Accumulate_derived",
 182                    MPI_Accumulate(rmabuf, count, derived_dtp, TARGET, 0,
 183                                   count, derived_dtp, MPI_SUM, win);
 184 );
 185         TEST_PT_OP("Get accumulate",
 186                    MPI_Get_accumulate(rmabuf, count, MPI_INT, result, count,
 187                                       MPI_INT, TARGET, 0, count, MPI_INT, MPI_SUM, win);
 188 );
 189
 190         /* Note: It's not possible to generate a zero-byte FOP or CAS */
 191
 192         /** TEST REQUEST-BASED OPERATIONS (PASSIVE TARGET ONLY) **/
 193
 194         TEST_REQ_OP("Rput", req,
 195                     MPI_Rput(rmabuf, count, MPI_INT, TARGET, 0, count, MPI_INT, win, &req);
 196 );
 197         TEST_REQ_OP("Rget", req,
 198                     MPI_Rget(rmabuf, count, MPI_INT, TARGET, 0, count, MPI_INT, win, &req);
 199 );
 200         TEST_REQ_OP("Raccumulate", req,
 201                     MPI_Raccumulate(rmabuf, count, MPI_INT, TARGET, 0,
 202                                     count, MPI_INT, MPI_SUM, win, &req);
 203 );
 204         TEST_REQ_OP("Raccumulate_derived", req,
 205                     MPI_Raccumulate(rmabuf, count, derived_dtp, TARGET, 0,
 206                                     count, derived_dtp, MPI_SUM, win, &req);
 207 );
 208         TEST_REQ_OP("Rget_accumulate", req,
 209                     MPI_Rget_accumulate(rmabuf, count, MPI_INT, result,
 210                                         count, MPI_INT, TARGET, 0,
 211                                         count, MPI_INT, MPI_SUM, win, &req);
 212 );
 213
 214         MPI_Win_free(&win);
 215         MTestFreeComm(&comm);
 216     }
 217
 218     MPI_Type_free(&derived_dtp);
 219
 220     free(result);
 221     free(buf);
 222     free(rmabuf);
 223     MTest_Finalize(errs);
 224     MPI_Finalize();
 225     return 0;
 226 }