teshsuite/smpi/mpich3-test/rma/fetchandadd_am.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 "stdlib.h"
   9 #include "mpitest.h"
  10
  11 /* Fetch and add example from Using MPI-2 (the non-scalable version,
  12    Fig. 6.12). */
  13
  14 /* same as fetchandadd.c but uses alloc_mem */
  15
  16 #define NTIMES 20       /* no of times each process calls the counter
  17                          * routine */
  18
  19 int localvalue = 0;             /* contribution of this process to the counter. We
  20                                  * define it as a global variable because attribute
  21                                  * caching on the window is not enabled yet. */
  22
  23 void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
  24                  int rank, int nprocs, int *value);
  25
  26 int compar(const void *a, const void *b);
  27
  28 int main(int argc, char *argv[])
  29 {
  30     int rank, nprocs, i, blens[2], disps[2], *counter_mem, *val_array, *results, *counter_vals;
  31     MPI_Datatype get_type;
  32     MPI_Win win;
  33     int errs = 0;
  34
  35     MTest_Init(&argc, &argv);
  36     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
  37     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  38
  39     if (rank == 0) {
  40         /* allocate counter memory and initialize to 0 */
  41         /* counter_mem = (int *) calloc(nprocs, sizeof(int)); */
  42
  43         i = MPI_Alloc_mem(nprocs * sizeof(int), MPI_INFO_NULL, &counter_mem);
  44         if (i) {
  45             printf("Can't allocate memory in test program\n");
  46             MPI_Abort(MPI_COMM_WORLD, 1);
  47         }
  48
  49         for (i = 0; i < nprocs; i++)
  50             counter_mem[i] = 0;
  51
  52         MPI_Win_create(counter_mem, nprocs * sizeof(int), sizeof(int),
  53                        MPI_INFO_NULL, MPI_COMM_WORLD, &win);
  54
  55         MPI_Win_free(&win);
  56         MPI_Free_mem(counter_mem);
  57
  58         /* gather the results from other processes, sort them, and check
  59          * whether they represent a counter being incremented by 1 */
  60
  61         results = (int *) malloc(NTIMES * nprocs * sizeof(int));
  62         for (i = 0; i < NTIMES * nprocs; i++)
  63             results[i] = -1;
  64
  65         MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 0, MPI_COMM_WORLD);
  66
  67         qsort(results + NTIMES, NTIMES * (nprocs - 1), sizeof(int), compar);
  68
  69         for (i = NTIMES + 1; i < (NTIMES * nprocs); i++)
  70             if (results[i] != results[i - 1] + 1)
  71                 errs++;
  72
  73         free(results);
  74     }
  75     else {
  76         blens[0] = rank;
  77         disps[0] = 0;
  78         blens[1] = nprocs - rank - 1;
  79         disps[1] = rank + 1;
  80
  81         MPI_Type_indexed(2, blens, disps, MPI_INT, &get_type);
  82         MPI_Type_commit(&get_type);
  83
  84         val_array = (int *) malloc(nprocs * sizeof(int));
  85
  86         /* allocate array to store the values obtained from the
  87          * fetch-and-add counter */
  88         counter_vals = (int *) malloc(NTIMES * sizeof(int));
  89
  90         MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
  91
  92         for (i = 0; i < NTIMES; i++) {
  93             Get_nextval(win, val_array, get_type, rank, nprocs, counter_vals + i);
  94             /* printf("Rank %d, counter %d\n", rank, value); */
  95         }
  96
  97         MPI_Win_free(&win);
  98
  99         free(val_array);
 100         MPI_Type_free(&get_type);
 101
 102         /* gather the results to the root */
 103         MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 0, MPI_COMM_WORLD);
 104         free(counter_vals);
 105     }
 106
 107     MTest_Finalize(errs);
 108     MPI_Finalize();
 109     return 0;
 110 }
 111
 112
 113 void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
 114                  int rank, int nprocs, int *value)
 115 {
 116     int one = 1, i;
 117
 118     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
 119     MPI_Accumulate(&one, 1, MPI_INT, 0, rank, 1, MPI_INT, MPI_SUM, win);
 120     MPI_Get(val_array, 1, get_type, 0, 0, 1, get_type, win);
 121     MPI_Win_unlock(0, win);
 122
 123     *value = 0;
 124     val_array[rank] = localvalue;
 125     for (i = 0; i < nprocs; i++)
 126         *value = *value + val_array[i];
 127
 128     localvalue++;
 129 }
 130
 131 int compar(const void *a, const void *b)
 132 {
 133     return (*((int *) a) - *((int *) b));
 134 }