examples/smpi/smpi_traced.c

   1 /* Copyright (c) 2009, 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "mpi.h"
   8 #include <stdio.h>
   9
  10 #define DATATOSENT 100000000
  11
  12 int main(int argc, char *argv[])
  13 {
  14   int rank, numprocs, i;
  15
  16   MPI_Init(&argc,&argv);
  17   MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
  18   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  19
  20   //Tests:
  21   //A: 0(isend -> wait) with 1(recv)
  22   int A = 1;
  23   //B: 0(send) with 1(irecv -> wait)
  24   int B = 1;
  25   //C: 0(N * isend -> N * wait) with 1(N * recv)
  26   int C = 1;
  27   //D: 0(N * isend -> N * waitany) with 1(N * recv)
  28   int D = 1;
  29   //E: 0(N*send) with 1(N*irecv, N*wait)
  30   int E = 1;
  31   //F: 0(N*send) with 1(N*irecv, N*waitany)
  32   int F = 1;
  33   //G: 0(N* isend -> waitall) with 1(N*recv)
  34   int G = 1;
  35   //H: 0(N*send) with 1(N*irecv, waitall)
  36   int H = 1;
  37   //I: 0(2*N*send, 2*N*Irecv, Waitall) with
  38   //   1(N*irecv, waitall, N*isend, N*waitany) with
  39   //   2(N*irecv, N*waitany, N*isend, waitall)
  40   int I = 1;
  41   //J: 0(N*isend, N*test, N*wait) with (N*irecv, N*test, N*wait)
  42   int J = 1;
  43
  44   int N = 13;
  45
  46   int tag = 12345;
  47 /////////////////////////////////////////
  48 ////////////////// RANK 0
  49 ///////////////////////////////////
  50   if (rank == 0){
  51     MPI_Request request;
  52     MPI_Status status;
  53     MPI_Request req[2*N];
  54     MPI_Status sta[2*N];
  55     int *r = (int*)malloc(sizeof(int)*DATATOSENT);
  56     if (A){
  57       MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &request);
  58       MPI_Wait (&request, &status);
  59     }
  60     MPI_Barrier (MPI_COMM_WORLD);
  61
  62     if (B){
  63       MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
  64     }
  65     MPI_Barrier (MPI_COMM_WORLD);
  66
  67     if (C){
  68       for (i = 0; i < N; i++){
  69         MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
  70       }
  71       for (i = 0; i < N; i++){
  72         MPI_Wait (&req[i], &sta[i]);
  73       }
  74     }
  75     MPI_Barrier (MPI_COMM_WORLD);
  76
  77     if (D){
  78       for (i = 0; i < N; i++){
  79         MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
  80       }
  81       for (i = 0; i < N; i++){
  82         int completed;
  83         MPI_Waitany (N, req, &completed, sta);
  84       }
  85     }
  86     MPI_Barrier (MPI_COMM_WORLD);
  87
  88     if (E){
  89       for (i = 0; i < N; i++){
  90         MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
  91       }
  92     }
  93     MPI_Barrier (MPI_COMM_WORLD);
  94
  95     if (F){
  96       for (i = 0; i < N; i++){
  97         MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
  98       }
  99     }
 100     MPI_Barrier (MPI_COMM_WORLD);
 101
 102     if (G){
 103       for (i = 0; i < N; i++){
 104         MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
 105       }
 106       MPI_Waitall (N, req, sta);
 107     }
 108     MPI_Barrier (MPI_COMM_WORLD);
 109
 110     if (H){
 111       for (i = 0; i < N; i++){
 112         MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
 113       }
 114     }
 115     MPI_Barrier (MPI_COMM_WORLD);
 116
 117     if (I){
 118       for (i = 0; i < 2*N; i++){
 119         if (i < N){
 120           MPI_Send(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD);
 121         }else{
 122           MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
 123         }
 124       }
 125       MPI_Barrier (MPI_COMM_WORLD);
 126       for (i = 0; i < 2*N; i++){
 127         if (i < N){
 128           MPI_Irecv(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
 129         }else{
 130           MPI_Irecv(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD, &req[i]);
 131         }
 132       }
 133       MPI_Waitall (2*N, req, sta);
 134     }
 135     MPI_Barrier (MPI_COMM_WORLD);
 136
 137     if (J){
 138       for (i = 0; i < N; i++){
 139         MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
 140       }
 141       for (i = 0; i < N; i++){
 142         int flag;
 143         MPI_Test (&req[i], &flag, &sta[i]);
 144       }
 145       for (i = 0; i < N; i++){
 146         MPI_Wait (&req[i], &sta[i]);
 147       }
 148     }
 149
 150 /////////////////////////////////////////
 151 ////////////////// RANK 1
 152 ///////////////////////////////////
 153   }else if (rank == 1){
 154     MPI_Request request;
 155     MPI_Status status;
 156     MPI_Request req[N];
 157     MPI_Status sta[N];
 158     int *r = (int*)malloc(sizeof(int)*DATATOSENT);
 159
 160     if (A){
 161       MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
 162     }
 163     MPI_Barrier (MPI_COMM_WORLD);
 164
 165     if (B){
 166       MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &request);
 167       MPI_Wait (&request, &status);
 168     }
 169     MPI_Barrier (MPI_COMM_WORLD);
 170
 171     if (C){
 172       for (i = 0; i < N; i++){
 173         MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
 174       }
 175     }
 176     MPI_Barrier (MPI_COMM_WORLD);
 177
 178     if (D){
 179       for (i = 0; i < N; i++){
 180         MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
 181       }
 182     }
 183     MPI_Barrier (MPI_COMM_WORLD);
 184
 185     if (E){
 186       for (i = 0; i < N; i++){
 187         MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
 188       }
 189       for (i = 0; i < N; i++){
 190         MPI_Wait (&req[i], &sta[i]);
 191       }
 192     }
 193     MPI_Barrier (MPI_COMM_WORLD);
 194
 195     if (F){
 196       for (i = 0; i < N; i++){
 197         MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
 198       }
 199       for (i = 0; i < N; i++){
 200         int completed;
 201         MPI_Waitany (N, req, &completed, sta);
 202       }
 203     }
 204     MPI_Barrier (MPI_COMM_WORLD);
 205
 206     if (G){
 207       for (i = 0; i < N; i++){
 208         MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
 209       }
 210     }
 211     MPI_Barrier (MPI_COMM_WORLD);
 212
 213     if (H){
 214       for (i = 0; i < N; i++){
 215         MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
 216       }
 217       MPI_Waitall (N, req, sta);
 218     }
 219     MPI_Barrier (MPI_COMM_WORLD);
 220
 221     if (I){
 222       for (i = 0; i < N; i++){
 223         MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
 224       }
 225       MPI_Waitall (N, req, sta);
 226
 227       MPI_Barrier (MPI_COMM_WORLD);
 228       for (i = 0; i < N; i++){
 229         MPI_Isend(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
 230       }
 231       MPI_Waitall (N, req, sta);
 232 //      for (i = 0; i < N; i++){
 233 //        MPI_Wait (&req[i], &sta[i]);
 234 //      }
 235     }
 236     MPI_Barrier (MPI_COMM_WORLD);
 237
 238     if (J){
 239       for (i = 0; i < N; i++){
 240         MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
 241       }
 242       for (i = 0; i < N; i++){
 243         int flag;
 244         MPI_Test (&req[i], &flag, &sta[i]);
 245       }
 246       for (i = 0; i < N; i++){
 247         MPI_Wait (&req[i], &sta[i]);
 248       }
 249     }
 250
 251 /////////////////////////////////////////
 252 ////////////////// RANK 2
 253 ///////////////////////////////////
 254   }else if (rank == 2){
 255 //    MPI_Request request;
 256 //    MPI_Status status;
 257     MPI_Request req[N];
 258     MPI_Status sta[N];
 259     int *r = (int*)malloc(sizeof(int)*DATATOSENT);
 260
 261     if (A) {}
 262     MPI_Barrier (MPI_COMM_WORLD);
 263     if (B) {}
 264     MPI_Barrier (MPI_COMM_WORLD);
 265     if (C) {}
 266     MPI_Barrier (MPI_COMM_WORLD);
 267     if (D) {}
 268     MPI_Barrier (MPI_COMM_WORLD);
 269     if (E) {}
 270     MPI_Barrier (MPI_COMM_WORLD);
 271     if (F) {}
 272     MPI_Barrier (MPI_COMM_WORLD);
 273     if (G) {}
 274     MPI_Barrier (MPI_COMM_WORLD);
 275     if (H) {}
 276     MPI_Barrier (MPI_COMM_WORLD);
 277     if (I){
 278       for (i = 0; i < N; i++){
 279         MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
 280       }
 281       for (i = 0; i < N; i++){
 282         int completed;
 283         MPI_Waitany (N, req, &completed, sta);
 284       }
 285       MPI_Barrier (MPI_COMM_WORLD);
 286
 287       for (i = 0; i < N; i++){
 288         MPI_Send(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD);
 289       }
 290     }
 291     MPI_Barrier (MPI_COMM_WORLD);
 292     if (J){}
 293   }
 294   MPI_Barrier (MPI_COMM_WORLD);
 295   MPI_Finalize();
 296   return 0;
 297 }