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

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *
   4  *  (C) 2013 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
 109     MTest_Init( &argc, &argv );
 110
 111     bufsize = 256 * sizeof(int);
 112     buf     = (int *)malloc( bufsize );
 113     if (!buf) {
 114         fprintf( stderr, "Unable to allocated %d bytes\n", bufsize );
 115         MPI_Abort( MPI_COMM_WORLD, 1 );
 116     }
 117     result  = (int *)malloc( bufsize );
 118     if (!result) {
 119         fprintf( stderr, "Unable to allocated %d bytes\n", bufsize );
 120         MPI_Abort( MPI_COMM_WORLD, 1 );
 121     }
 122     rcount   = 16;
 123     rsize    = rcount * sizeof(int);
 124     rmabuf   = (int *)malloc( rsize );
 125     if (!rmabuf) {
 126         fprintf( stderr, "Unable to allocated %d bytes\n", rsize );
 127         MPI_Abort( MPI_COMM_WORLD, 1 );
 128     }
 129
 130     /* The following loop is used to run through a series of communicators
 131      * that are subsets of MPI_COMM_WORLD, of size 1 or greater. */
 132     while (MTestGetIntracommGeneral( &comm, 1, 1 )) {
 133         int count = 0;
 134
 135         if (comm == MPI_COMM_NULL) continue;
 136         /* Determine the sender and receiver */
 137         MPI_Comm_rank( comm, &rank );
 138         MPI_Comm_size( comm, &size );
 139
 140         MPI_Win_create( buf, bufsize, sizeof(int), MPI_INFO_NULL, comm, &win );
 141         /* To improve reporting of problems about operations, we
 142            change the error handler to errors return */
 143         MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
 144
 145         /** TEST OPERATIONS USING ACTIVE TARGET (FENCE) SYNCHRONIZATION **/
 146         MPI_Win_fence( 0, win );
 147
 148         TEST_FENCE_OP("Put",
 149                       MPI_Put( rmabuf, count, MPI_INT, TARGET, 0,
 150                                count, MPI_INT, win );
 151                      );
 152
 153         TEST_FENCE_OP("Get",
 154                       MPI_Get( rmabuf, count, MPI_INT, TARGET, 0,
 155                                count, MPI_INT, win );
 156                      );
 157         TEST_FENCE_OP("Accumulate",
 158                       MPI_Accumulate( rmabuf, count, MPI_INT, TARGET,
 159                                       0, count, MPI_INT, MPI_SUM, win );
 160                      );
 161         TEST_FENCE_OP("Get accumulate",
 162                       MPI_Get_accumulate( rmabuf, count, MPI_INT, result,
 163                                           count, MPI_INT, TARGET, 0,
 164                                           count, MPI_INT, MPI_SUM, win );
 165                      );
 166         /* Note: It's not possible to generate a zero-byte FOP or CAS */
 167
 168         /** TEST OPERATIONS USING PASSIVE TARGET SYNCHRONIZATION **/
 169
 170         TEST_PT_OP("Put",
 171                    MPI_Put( rmabuf, count, MPI_INT, TARGET, 0, count,
 172                             MPI_INT, win );
 173                    );
 174         TEST_PT_OP("Get",
 175                    MPI_Get( rmabuf, count, MPI_INT, TARGET, 0, count,
 176                             MPI_INT, win );
 177                    );
 178         TEST_PT_OP("Accumulate",
 179                    MPI_Accumulate( rmabuf, count, MPI_INT, TARGET, 0,
 180                                    count, MPI_INT, MPI_SUM, win );
 181                    );
 182         TEST_PT_OP("Get accumulate",
 183                    MPI_Get_accumulate( rmabuf, count, MPI_INT, result, count,
 184                                        MPI_INT, TARGET, 0, count,
 185                                        MPI_INT, MPI_SUM, win );
 186                    );
 187
 188         /* Note: It's not possible to generate a zero-byte FOP or CAS */
 189
 190         /** TEST REQUEST-BASED OPERATIONS (PASSIVE TARGET ONLY) **/
 191
 192         TEST_REQ_OP("Rput", req,
 193                     MPI_Rput( rmabuf, count, MPI_INT, TARGET, 0, count,
 194                               MPI_INT, win, &req );
 195                    );
 196         TEST_REQ_OP("Rget", req,
 197                     MPI_Rget( rmabuf, count, MPI_INT, TARGET, 0, count,
 198                               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("Rget_accumulate", req,
 205                     MPI_Rget_accumulate( rmabuf, count, MPI_INT, result,
 206                                          count, MPI_INT, TARGET, 0,
 207                                          count, MPI_INT, MPI_SUM, win, &req );
 208                    );
 209
 210         MPI_Win_free( &win );
 211         MTestFreeComm(&comm);
 212     }
 213
 214     free( result );
 215     free( buf );
 216     free( rmabuf );
 217     MTest_Finalize( errs );
 218     MPI_Finalize();
 219     return 0;
 220 }