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

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *  (C) 2010 by Argonne National Laboratory.
   4  *      See COPYRIGHT in top-level directory.
   5  */
   6
   7 /* This test is a simplification of the one in perf/manyrma.c that tests
   8    for correct handling of the case where many RMA operations occur between
   9    synchronization events.
  10    This is one of the ways that RMA may be used, and is used in the
  11    reference implementation of the graph500 benchmark.
  12 */
  13 #include "mpi.h"
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17
  18 #define MAX_COUNT 65536*4/16
  19 #define MAX_RMA_SIZE 2  /* 16 in manyrma performance test */
  20 #define MAX_RUNS 10
  21 #define MAX_ITER_TIME  5.0      /* seconds */
  22
  23 typedef enum { SYNC_NONE = 0,
  24     SYNC_ALL = -1, SYNC_FENCE = 1, SYNC_LOCK = 2, SYNC_PSCW = 4
  25 } sync_t;
  26 typedef enum { RMA_NONE = 0, RMA_ALL = -1, RMA_PUT = 1, RMA_ACC = 2, RMA_GET = 4 } rma_t;
  27 /* Note GET not yet implemented */
  28 /* By default, run only a subset of the available tests, to keep the
  29    total runtime reasonably short.  Command line arguments may be used
  30    to run other tests. */
  31 sync_t syncChoice = SYNC_FENCE;
  32 rma_t rmaChoice = RMA_ACC;
  33
  34 static int verbose = 0;
  35
  36 void RunAccFence(MPI_Win win, int destRank, int cnt, int sz);
  37 void RunAccLock(MPI_Win win, int destRank, int cnt, int sz);
  38 void RunPutFence(MPI_Win win, int destRank, int cnt, int sz);
  39 void RunPutLock(MPI_Win win, int destRank, int cnt, int sz);
  40 void RunAccPSCW(MPI_Win win, int destRank, int cnt, int sz,
  41                 MPI_Group exposureGroup, MPI_Group accessGroup);
  42 void RunPutPSCW(MPI_Win win, int destRank, int cnt, int sz,
  43                 MPI_Group exposureGroup, MPI_Group accessGroup);
  44
  45 int main(int argc, char *argv[])
  46 {
  47     int arraysize, i, cnt, sz, maxCount = MAX_COUNT, *arraybuffer;
  48     int wrank, wsize, destRank, srcRank;
  49     MPI_Win win;
  50     MPI_Group wgroup, accessGroup, exposureGroup;
  51     int maxSz = MAX_RMA_SIZE;
  52     double start, end;
  53
  54     MPI_Init(&argc, &argv);
  55
  56     for (i = 1; i < argc; i++) {
  57         if (strcmp(argv[i], "-put") == 0) {
  58             if (rmaChoice == RMA_ALL)
  59                 rmaChoice = RMA_NONE;
  60             rmaChoice |= RMA_PUT;
  61         }
  62         else if (strcmp(argv[i], "-acc") == 0) {
  63             if (rmaChoice == RMA_ALL)
  64                 rmaChoice = RMA_NONE;
  65             rmaChoice |= RMA_ACC;
  66         }
  67         else if (strcmp(argv[i], "-fence") == 0) {
  68             if (syncChoice == SYNC_ALL)
  69                 syncChoice = SYNC_NONE;
  70             syncChoice |= SYNC_FENCE;
  71         }
  72         else if (strcmp(argv[i], "-lock") == 0) {
  73             if (syncChoice == SYNC_ALL)
  74                 syncChoice = SYNC_NONE;
  75             syncChoice |= SYNC_LOCK;
  76         }
  77         else if (strcmp(argv[i], "-pscw") == 0) {
  78             if (syncChoice == SYNC_ALL)
  79                 syncChoice = SYNC_NONE;
  80             syncChoice |= SYNC_PSCW;
  81         }
  82         else if (strcmp(argv[i], "-maxsz") == 0) {
  83             i++;
  84             maxSz = atoi(argv[i]);
  85         }
  86         else if (strcmp(argv[i], "-maxcount") == 0) {
  87             i++;
  88             maxCount = atoi(argv[i]);
  89         }
  90         else {
  91             fprintf(stderr, "Unrecognized argument %s\n", argv[i]);
  92             fprintf(stderr,
  93                     "%s [ -put ] [ -acc ] [ -lock ] [ -fence ] [ -pscw ] [ -maxsz msgsize ]\n",
  94                     argv[0]);
  95             MPI_Abort(MPI_COMM_WORLD, 1);
  96         }
  97     }
  98
  99     MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
 100     MPI_Comm_size(MPI_COMM_WORLD, &wsize);
 101     destRank = wrank + 1;
 102     while (destRank >= wsize)
 103         destRank = destRank - wsize;
 104     srcRank = wrank - 1;
 105     if (srcRank < 0)
 106         srcRank += wsize;
 107
 108     /* Create groups for PSCW */
 109     MPI_Comm_group(MPI_COMM_WORLD, &wgroup);
 110     MPI_Group_incl(wgroup, 1, &destRank, &accessGroup);
 111     MPI_Group_incl(wgroup, 1, &srcRank, &exposureGroup);
 112     MPI_Group_free(&wgroup);
 113
 114     arraysize = maxSz * MAX_COUNT;
 115     arraybuffer = (int *) malloc(arraysize * sizeof(int));
 116     if (!arraybuffer) {
 117         fprintf(stderr, "Unable to allocate %d words\n", arraysize);
 118         MPI_Abort(MPI_COMM_WORLD, 1);
 119     }
 120
 121     MPI_Win_create(arraybuffer, arraysize * sizeof(int), (int) sizeof(int),
 122                    MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 123
 124     if (maxCount > MAX_COUNT) {
 125         fprintf(stderr, "MaxCount must not exceed %d\n", MAX_COUNT);
 126         MPI_Abort(MPI_COMM_WORLD, 1);
 127     }
 128
 129     if ((syncChoice & SYNC_FENCE) && (rmaChoice & RMA_ACC)) {
 130         for (sz = 1; sz <= maxSz; sz = sz + sz) {
 131             if (wrank == 0 && verbose)
 132                 printf("Accumulate with fence, %d elements\n", sz);
 133             for (cnt = 1; cnt <= maxCount; cnt *= 2) {
 134                 start = MPI_Wtime();
 135                 RunAccFence(win, destRank, cnt, sz);
 136                 end = MPI_Wtime();
 137                 if (end - start > MAX_ITER_TIME)
 138                     break;
 139             }
 140         }
 141     }
 142
 143     if ((syncChoice & SYNC_LOCK) && (rmaChoice & RMA_ACC)) {
 144         for (sz = 1; sz <= maxSz; sz = sz + sz) {
 145             if (wrank == 0 && verbose)
 146                 printf("Accumulate with lock, %d elements\n", sz);
 147             for (cnt = 1; cnt <= maxCount; cnt *= 2) {
 148                 start = MPI_Wtime();
 149                 RunAccLock(win, destRank, cnt, sz);
 150                 end = MPI_Wtime();
 151                 if (end - start > MAX_ITER_TIME)
 152                     break;
 153             }
 154         }
 155     }
 156
 157     if ((syncChoice & SYNC_FENCE) && (rmaChoice & RMA_PUT)) {
 158         for (sz = 1; sz <= maxSz; sz = sz + sz) {
 159             if (wrank == 0 && verbose)
 160                 printf("Put with fence, %d elements\n", sz);
 161             for (cnt = 1; cnt <= maxCount; cnt *= 2) {
 162                 start = MPI_Wtime();
 163                 RunPutFence(win, destRank, cnt, sz);
 164                 end = MPI_Wtime();
 165                 if (end - start > MAX_ITER_TIME)
 166                     break;
 167             }
 168         }
 169     }
 170
 171     if ((syncChoice & SYNC_LOCK) && (rmaChoice & RMA_PUT)) {
 172         for (sz = 1; sz <= maxSz; sz = sz + sz) {
 173             if (wrank == 0 && verbose)
 174                 printf("Put with lock, %d elements\n", sz);
 175             for (cnt = 1; cnt <= maxCount; cnt *= 2) {
 176                 start = MPI_Wtime();
 177                 RunPutLock(win, destRank, cnt, sz);
 178                 end = MPI_Wtime();
 179                 if (end - start > MAX_ITER_TIME)
 180                     break;
 181             }
 182         }
 183     }
 184
 185     if ((syncChoice & SYNC_PSCW) && (rmaChoice & RMA_PUT)) {
 186         for (sz = 1; sz <= maxSz; sz = sz + sz) {
 187             if (wrank == 0 && verbose)
 188                 printf("Put with pscw, %d elements\n", sz);
 189             for (cnt = 1; cnt <= maxCount; cnt *= 2) {
 190                 start = MPI_Wtime();
 191                 RunPutPSCW(win, destRank, cnt, sz, exposureGroup, accessGroup);
 192                 end = MPI_Wtime();
 193                 if (end - start > MAX_ITER_TIME)
 194                     break;
 195             }
 196         }
 197     }
 198
 199     if ((syncChoice & SYNC_PSCW) && (rmaChoice & RMA_ACC)) {
 200         for (sz = 1; sz <= maxSz; sz = sz + sz) {
 201             if (wrank == 0 && verbose)
 202                 printf("Accumulate with pscw, %d elements\n", sz);
 203             for (cnt = 1; cnt <= maxCount; cnt *= 2) {
 204                 start = MPI_Wtime();
 205                 RunAccPSCW(win, destRank, cnt, sz, exposureGroup, accessGroup);
 206                 end = MPI_Wtime();
 207                 if (end - start > MAX_ITER_TIME)
 208                     break;
 209             }
 210         }
 211     }
 212
 213     MPI_Win_free(&win);
 214
 215     MPI_Group_free(&accessGroup);
 216     MPI_Group_free(&exposureGroup);
 217
 218     /* If we get here without timing out or failing, we succeeded */
 219     if (wrank == 0)
 220         printf(" No Errors\n");
 221
 222     MPI_Finalize();
 223     return 0;
 224 }
 225
 226
 227 void RunAccFence(MPI_Win win, int destRank, int cnt, int sz)
 228 {
 229     int k, i, j, one = 1;
 230
 231     for (k = 0; k < MAX_RUNS; k++) {
 232         MPI_Barrier(MPI_COMM_WORLD);
 233         MPI_Win_fence(0, win);
 234         j = 0;
 235         for (i = 0; i < cnt; i++) {
 236             MPI_Accumulate(&one, sz, MPI_INT, destRank, j, sz, MPI_INT, MPI_SUM, win);
 237             j += sz;
 238         }
 239         MPI_Win_fence(0, win);
 240     }
 241 }
 242
 243 void RunAccLock(MPI_Win win, int destRank, int cnt, int sz)
 244 {
 245     int k, i, j, one = 1;
 246
 247     for (k = 0; k < MAX_RUNS; k++) {
 248         MPI_Barrier(MPI_COMM_WORLD);
 249         MPI_Win_lock(MPI_LOCK_SHARED, destRank, 0, win);
 250         j = 0;
 251         for (i = 0; i < cnt; i++) {
 252             MPI_Accumulate(&one, sz, MPI_INT, destRank, j, sz, MPI_INT, MPI_SUM, win);
 253             j += sz;
 254         }
 255         MPI_Win_unlock(destRank, win);
 256     }
 257 }
 258
 259 void RunPutFence(MPI_Win win, int destRank, int cnt, int sz)
 260 {
 261     int k, i, j, one = 1;
 262
 263     for (k = 0; k < MAX_RUNS; k++) {
 264         MPI_Barrier(MPI_COMM_WORLD);
 265         MPI_Win_fence(0, win);
 266         j = 0;
 267         for (i = 0; i < cnt; i++) {
 268             MPI_Put(&one, sz, MPI_INT, destRank, j, sz, MPI_INT, win);
 269             j += sz;
 270         }
 271         MPI_Win_fence(0, win);
 272     }
 273 }
 274
 275 void RunPutLock(MPI_Win win, int destRank, int cnt, int sz)
 276 {
 277     int k, i, j, one = 1;
 278
 279     for (k = 0; k < MAX_RUNS; k++) {
 280         MPI_Barrier(MPI_COMM_WORLD);
 281         MPI_Win_lock(MPI_LOCK_SHARED, destRank, 0, win);
 282         j = 0;
 283         for (i = 0; i < cnt; i++) {
 284             MPI_Put(&one, sz, MPI_INT, destRank, j, sz, MPI_INT, win);
 285             j += sz;
 286         }
 287         MPI_Win_unlock(destRank, win);
 288     }
 289 }
 290
 291 void RunPutPSCW(MPI_Win win, int destRank, int cnt, int sz,
 292                 MPI_Group exposureGroup, MPI_Group accessGroup)
 293 {
 294     int k, i, j, one = 1;
 295
 296     for (k = 0; k < MAX_RUNS; k++) {
 297         MPI_Barrier(MPI_COMM_WORLD);
 298         MPI_Win_post(exposureGroup, 0, win);
 299         MPI_Win_start(accessGroup, 0, win);
 300         j = 0;
 301         for (i = 0; i < cnt; i++) {
 302             MPI_Put(&one, sz, MPI_INT, destRank, j, sz, MPI_INT, win);
 303             j += sz;
 304         }
 305         MPI_Win_complete(win);
 306         MPI_Win_wait(win);
 307     }
 308 }
 309
 310 void RunAccPSCW(MPI_Win win, int destRank, int cnt, int sz,
 311                 MPI_Group exposureGroup, MPI_Group accessGroup)
 312 {
 313     int k, i, j, one = 1;
 314
 315     for (k = 0; k < MAX_RUNS; k++) {
 316         MPI_Barrier(MPI_COMM_WORLD);
 317         MPI_Win_post(exposureGroup, 0, win);
 318         MPI_Win_start(accessGroup, 0, win);
 319         j = 0;
 320         for (i = 0; i < cnt; i++) {
 321             MPI_Accumulate(&one, sz, MPI_INT, destRank, j, sz, MPI_INT, MPI_SUM, win);
 322             j += sz;
 323         }
 324         MPI_Win_complete(win);
 325         MPI_Win_wait(win);
 326     }
 327 }