Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Coding style: prefer keyword "not" to "!".
[simgrid.git] / examples / smpi / trace / trace.c
1 /* Copyright (c) 2009-2022. 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 <stdio.h>
8 #include "mpi.h"
9 #include "simgrid/instr.h"
10 #include <unistd.h>
11
12 #define DATATOSENT 100000
13
14 int main(int argc, char *argv[])
15 {
16   int rank;
17   int numprocs;
18
19   MPI_Init(&argc, &argv);
20   MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
21   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
22   sleep(rank);
23   /** Tests:
24   * A: 0(isend -> wait) with 1(recv)
25   * B: 0(send) with 1(irecv -> wait)
26   * C: 0(N * isend -> N * wait) with 1(N * recv)
27   * D: 0(N * isend -> N * waitany) with 1(N * recv)
28   * E: 0(N*send) with 1(N*irecv, N*wait)
29   * F: 0(N*send) with 1(N*irecv, N*waitany)
30   * G: 0(N* isend -> waitall) with 1(N*recv)
31   * H: 0(N*send) with 1(N*irecv, waitall)
32   * I: 0(2*N*send, 2*N*Irecv, Waitall) with
33   *    1(N*irecv, waitall, N*isend, N*waitany) with
34   *    2(N*irecv, N*waitany, N*isend, waitall)
35   * J: 0(N*isend, N*test, N*wait) with (N*irecv, N*test, N*wait)
36   s*/
37   int N = 13;
38
39   int tag = 12345;
40 /////////////////////////////////////////
41 ////////////////// RANK 0
42 ///////////////////////////////////
43   if (rank == 0) {
44     MPI_Request request;
45     MPI_Status status;
46     MPI_Request req[2 * N];
47     MPI_Status sta[2 * N];
48     int *r = (int *) malloc(sizeof(int) * DATATOSENT);
49
50     /** Test A */
51     TRACE_smpi_set_category("A");
52     MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &request);
53     MPI_Wait(&request, &status);
54     MPI_Barrier(MPI_COMM_WORLD);
55
56     /** Test B */
57     TRACE_smpi_set_category("B");
58     MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
59     MPI_Barrier(MPI_COMM_WORLD);
60
61     /** Test C */
62     TRACE_smpi_set_category("C");
63     for (int i = 0; i < N; i++) {
64       MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
65     }
66     for (int i = 0; i < N; i++) {
67       MPI_Wait(&req[i], &sta[i]);
68     }
69     MPI_Barrier(MPI_COMM_WORLD);
70
71     TRACE_smpi_set_category("D");
72     for (int i = 0; i < N; i++) {
73       MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
74     }
75     for (int i = 0; i < N; i++) {
76       int completed;
77       MPI_Waitany(N, req, &completed, sta);
78     }
79     MPI_Barrier(MPI_COMM_WORLD);
80
81     TRACE_smpi_set_category("E");
82     for (int i = 0; i < N; i++) {
83       MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
84     }
85     MPI_Barrier(MPI_COMM_WORLD);
86
87     TRACE_smpi_set_category("F");
88     for (int i = 0; i < N; i++) {
89       MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
90     }
91     MPI_Barrier(MPI_COMM_WORLD);
92
93     TRACE_smpi_set_category("G");
94     for (int i = 0; i < N; i++) {
95       MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
96     }
97     MPI_Waitall(N, req, sta);
98     MPI_Barrier(MPI_COMM_WORLD);
99
100     TRACE_smpi_set_category("H");
101     for (int i = 0; i < N; i++) {
102       MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
103     }
104     MPI_Barrier(MPI_COMM_WORLD);
105
106     TRACE_smpi_set_category("I");
107     for (int i = 0; i < 2 * N; i++) {
108       if (i < N) {
109         MPI_Send(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD);
110       } else {
111         MPI_Send(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD);
112       }
113     }
114     MPI_Barrier(MPI_COMM_WORLD);
115     for (int i = 0; i < 2 * N; i++) {
116       if (i < N) {
117         MPI_Irecv(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
118       } else {
119         MPI_Irecv(r, DATATOSENT, MPI_INT, 2, tag, MPI_COMM_WORLD, &req[i]);
120       }
121     }
122     MPI_Waitall(2 * N, req, sta);
123     MPI_Barrier(MPI_COMM_WORLD);
124
125     TRACE_smpi_set_category("J");
126     for (int i = 0; i < N; i++) {
127       MPI_Isend(r, DATATOSENT, MPI_INT, 1, tag, MPI_COMM_WORLD, &req[i]);
128     }
129     for (int i = 0; i < N; i++) {
130       int flag;
131       MPI_Test(&req[i], &flag, &sta[i]);
132     }
133     for (int i = 0; i < N; i++) {
134       MPI_Wait(&req[i], &sta[i]);
135     }
136     free(r);
137 /////////////////////////////////////////
138 ////////////////// RANK 1
139 ///////////////////////////////////
140   } else if (rank == 1) {
141     MPI_Request request;
142     MPI_Status status;
143     MPI_Request req[N];
144     MPI_Status sta[N];
145     int *r = (int *) malloc(sizeof(int) * DATATOSENT);
146
147     TRACE_smpi_set_category("A");
148     MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
149     MPI_Barrier(MPI_COMM_WORLD);
150
151     TRACE_smpi_set_category("B");
152     MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &request);
153     MPI_Wait(&request, &status);
154     MPI_Barrier(MPI_COMM_WORLD);
155
156     TRACE_smpi_set_category("C");
157     for (int i = 0; i < N; i++) {
158       MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
159     }
160     MPI_Barrier(MPI_COMM_WORLD);
161
162     TRACE_smpi_set_category("D");
163     for (int i = 0; i < N; i++) {
164       MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
165     }
166     MPI_Barrier(MPI_COMM_WORLD);
167
168     TRACE_smpi_set_category("E");
169     for (int i = 0; i < N; i++) {
170       MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
171     }
172     for (int i = 0; i < N; i++) {
173       MPI_Wait(&req[i], &sta[i]);
174     }
175     MPI_Barrier(MPI_COMM_WORLD);
176
177     TRACE_smpi_set_category("F");
178     for (int i = 0; i < N; i++) {
179       MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
180     }
181     for (int i = 0; i < N; i++) {
182       int completed;
183       MPI_Waitany(N, req, &completed, sta);
184     }
185     MPI_Barrier(MPI_COMM_WORLD);
186
187     TRACE_smpi_set_category("G");
188     for (int i = 0; i < N; i++) {
189       MPI_Recv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &sta[i]);
190     }
191     MPI_Barrier(MPI_COMM_WORLD);
192
193     TRACE_smpi_set_category("H");
194     for (int i = 0; i < N; i++) {
195       MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
196     }
197     MPI_Waitall(N, req, sta);
198     MPI_Barrier(MPI_COMM_WORLD);
199
200     TRACE_smpi_set_category("I");
201     for (int i = 0; i < N; i++) {
202       MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
203     }
204     MPI_Waitall(N, req, sta);
205
206     MPI_Barrier(MPI_COMM_WORLD);
207     for (int i = 0; i < N; i++) {
208       MPI_Isend(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
209     }
210     MPI_Waitall(N, req, sta);
211     MPI_Barrier(MPI_COMM_WORLD);
212
213     TRACE_smpi_set_category("J");
214     for (int i = 0; i < N; i++) {
215       MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
216     }
217     for (int i = 0; i < N; i++) {
218       int flag;
219       MPI_Test(&req[i], &flag, &sta[i]);
220     }
221     for (int i = 0; i < N; i++) {
222       MPI_Wait(&req[i], &sta[i]);
223     }
224     free(r);
225 /////////////////////////////////////////
226 ////////////////// RANK 2
227 ///////////////////////////////////
228   } else if (rank == 2) {
229     MPI_Request req[N];
230     MPI_Status sta[N];
231     int *r = (int *) malloc(sizeof(int) * DATATOSENT);
232
233     MPI_Barrier(MPI_COMM_WORLD);
234     MPI_Barrier(MPI_COMM_WORLD);
235     MPI_Barrier(MPI_COMM_WORLD);
236     MPI_Barrier(MPI_COMM_WORLD);
237     MPI_Barrier(MPI_COMM_WORLD);
238     MPI_Barrier(MPI_COMM_WORLD);
239     MPI_Barrier(MPI_COMM_WORLD);
240     MPI_Barrier(MPI_COMM_WORLD);
241     TRACE_smpi_set_category("I");
242     for (int i = 0; i < N; i++) {
243       MPI_Irecv(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD, &req[i]);
244     }
245     for (int i = 0; i < N; i++) {
246       int completed;
247       MPI_Waitany(N, req, &completed, sta);
248     }
249     MPI_Barrier(MPI_COMM_WORLD);
250
251     for (int i = 0; i < N; i++) {
252       MPI_Send(r, DATATOSENT, MPI_INT, 0, tag, MPI_COMM_WORLD);
253     }
254     MPI_Barrier(MPI_COMM_WORLD);
255     free(r);
256   }
257   MPI_Barrier(MPI_COMM_WORLD);
258   MPI_Finalize();
259   return 0;
260 }