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

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *  (C) 2013 by Argonne National Laboratory.
   4  *      See COPYRIGHT in top-level directory.
   5  */
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <assert.h>
   9 #include <string.h>
  10 #include <mpi.h>
  11
  12 #define MAX_DATA_SIZE   (1024*128*16)
  13 #define MAX_NUM_ITERATIONS (8192*4)
  14 #define MIN_NUM_ITERATIONS 8
  15 #define NUM_WARMUP_ITER 1
  16
  17 const int verbose = 0;
  18 static int rank;
  19
  20 void run_test(int lock_mode, int lock_assert)
  21 {
  22     int nproc, test_iter, target_rank, data_size;
  23     int *buf, *win_buf;
  24     MPI_Win win;
  25
  26     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  27     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
  28
  29     if (rank == 0 && verbose) {
  30         printf("Starting one-sided contiguous performance test with %d processes\n", nproc);
  31
  32         printf("Synchronization mode: ");
  33
  34         switch (lock_mode) {
  35         case MPI_LOCK_EXCLUSIVE:
  36             printf("Exclusive lock");
  37             break;
  38         case MPI_LOCK_SHARED:
  39             printf("Shared lock");
  40             break;
  41         default:
  42             printf("Unknown lock");
  43             break;
  44         }
  45
  46         if (lock_assert & MPI_MODE_NOCHECK)
  47             printf(", MPI_MODE_NOCHECK");
  48
  49         printf("\n");
  50     }
  51
  52     MPI_Alloc_mem(MAX_DATA_SIZE, MPI_INFO_NULL, &buf);
  53     MPI_Alloc_mem(MAX_DATA_SIZE, MPI_INFO_NULL, &win_buf);
  54     memset(buf, rank, MAX_DATA_SIZE);
  55     memset(win_buf, rank, MAX_DATA_SIZE);
  56     MPI_Win_create(win_buf, MAX_DATA_SIZE, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
  57
  58     if (rank == 0 && verbose)
  59         printf("%12s %12s %12s %12s %12s %12s %12s %12s\n", "Trg. Rank", "Xfer Size",
  60                "Get (usec)", "Put (usec)", "Acc (usec)",
  61                "Get (MiB/s)", "Put (MiB/s)", "Acc (MiB/s)");
  62
  63     for (target_rank = 0; rank == 0 && target_rank < nproc; target_rank++) {
  64         for (data_size = sizeof(double); data_size <= MAX_DATA_SIZE; data_size *= 2) {
  65             double t_get, t_put, t_acc;
  66             int num_iter = MAX_NUM_ITERATIONS;
  67
  68             /* Scale the number of iterations by log_2 of the data size, so
  69              * that we run each test for a reasonable amount of time. */
  70             {
  71                 int t = data_size, my_log2 = 0;
  72                 while (t >>= 1)
  73                     my_log2++;
  74                 if (my_log2)
  75                     num_iter = (num_iter / my_log2 < MIN_NUM_ITERATIONS) ?
  76                         MIN_NUM_ITERATIONS : num_iter / my_log2;
  77             }
  78
  79             for (test_iter = 0; test_iter < num_iter + NUM_WARMUP_ITER; test_iter++) {
  80                 if (test_iter == NUM_WARMUP_ITER)
  81                     t_get = MPI_Wtime();
  82
  83                 MPI_Win_lock(lock_mode, target_rank, lock_assert, win);
  84                 MPI_Get(buf, data_size, MPI_BYTE, target_rank, 0, data_size, MPI_BYTE, win);
  85                 MPI_Win_unlock(target_rank, win);
  86             }
  87             t_get = (MPI_Wtime() - t_get) / num_iter;
  88
  89             for (test_iter = 0; test_iter < num_iter + NUM_WARMUP_ITER; test_iter++) {
  90                 if (test_iter == NUM_WARMUP_ITER)
  91                     t_put = MPI_Wtime();
  92
  93                 MPI_Win_lock(lock_mode, target_rank, lock_assert, win);
  94                 MPI_Put(buf, data_size, MPI_BYTE, target_rank, 0, data_size, MPI_BYTE, win);
  95                 MPI_Win_unlock(target_rank, win);
  96             }
  97             t_put = (MPI_Wtime() - t_put) / num_iter;
  98
  99             for (test_iter = 0; test_iter < num_iter + NUM_WARMUP_ITER; test_iter++) {
 100                 if (test_iter == NUM_WARMUP_ITER)
 101                     t_acc = MPI_Wtime();
 102
 103                 MPI_Win_lock(lock_mode, target_rank, lock_assert, win);
 104                 MPI_Accumulate(buf, data_size / sizeof(int), MPI_INT, target_rank,
 105                                0, data_size / sizeof(int), MPI_INT, MPI_SUM, win);
 106                 MPI_Win_unlock(target_rank, win);
 107             }
 108             t_acc = (MPI_Wtime() - t_acc) / num_iter;
 109
 110             if (rank == 0 && verbose)
 111                 printf("%12d %12d %12.3f %12.3f %12.3f %12.3f %12.3f %12.3f\n", target_rank,
 112                        data_size, t_get * 1.0e6, t_put * 1.0e6, t_acc * 1.0e6,
 113                        data_size / (1024.0 * 1024.0) / t_get, data_size / (1024.0 * 1024.0) / t_put,
 114                        data_size / (1024.0 * 1024.0) / t_acc);
 115         }
 116     }
 117
 118     MPI_Barrier(MPI_COMM_WORLD);
 119
 120     MPI_Win_free(&win);
 121     MPI_Free_mem(win_buf);
 122     MPI_Free_mem(buf);
 123 }
 124
 125 int main(int argc, char **argv)
 126 {
 127     MPI_Init(&argc, &argv);
 128
 129     run_test(MPI_LOCK_EXCLUSIVE, 0);
 130     run_test(MPI_LOCK_EXCLUSIVE, MPI_MODE_NOCHECK);
 131     run_test(MPI_LOCK_SHARED, 0);
 132     run_test(MPI_LOCK_SHARED, MPI_MODE_NOCHECK);
 133
 134     MPI_Finalize();
 135
 136     if (rank == 0)
 137         printf(" No Errors\n");
 138
 139     return 0;
 140 }