Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
increasing the message size for testing
[simgrid.git] / 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 }