Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix more Doxygen warnings.
[simgrid.git] / include / simgrid / smpi / replay.hpp
1 /* Copyright (c) 2009-2018. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5 #include "private.hpp"
6 #include <xbt/replay.hpp>
7
8 #include <sstream>
9
10 #define CHECK_ACTION_PARAMS(action, mandatory, optional)                                                             \
11 {                                                                                                                    \
12   if (action.size() < static_cast<unsigned long>(mandatory + 2)) {                                                   \
13     std::stringstream ss;                                                                                            \
14     for (const auto& elem : action) {                                                                                \
15       ss << elem << " ";                                                                                             \
16     }                                                                                                                \
17     THROWF(arg_error, 0, "%s replay failed.\n"                                                                       \
18                          "%zu items were given on the line. First two should be process_id and action.  "            \
19                          "This action needs after them %lu mandatory arguments, and accepts %lu optional ones. \n"   \
20                          "The full line that was given is:\n   %s\n"                                                 \
21                          "Please contact the Simgrid team if support is needed",                                     \
22            __func__, action.size(), static_cast<unsigned long>(mandatory), static_cast<unsigned long>(optional),     \
23            ss.str().c_str());                                                                                        \
24   }                                                                                                                  \
25 }
26
27 namespace simgrid {
28 namespace smpi {
29 namespace replay {
30 extern MPI_Datatype MPI_DEFAULT_TYPE;
31
32 class RequestStorage; // Forward decl
33
34 /**
35  * Base class for all parsers.
36  */
37 class ActionArgParser {
38 public:
39   virtual ~ActionArgParser() = default;
40   virtual void parse(simgrid::xbt::ReplayAction& action, std::string name) { CHECK_ACTION_PARAMS(action, 0, 0) }
41 };
42
43 class WaitTestParser : public ActionArgParser {
44 public:
45   int src;
46   int dst;
47   int tag;
48
49   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
50 };
51
52 class SendRecvParser : public ActionArgParser {
53 public:
54   /* communication partner; if we send, this is the receiver and vice versa */
55   int partner;
56   double size;
57   int tag;
58   MPI_Datatype datatype1 = MPI_DEFAULT_TYPE;
59
60   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
61 };
62
63 class ComputeParser : public ActionArgParser {
64 public:
65   /* communication partner; if we send, this is the receiver and vice versa */
66   double flops;
67
68   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
69 };
70
71 class CollCommParser : public ActionArgParser {
72 public:
73   double size;
74   double comm_size;
75   double comp_size;
76   int send_size;
77   int recv_size;
78   int root = 0;
79   MPI_Datatype datatype1 = MPI_DEFAULT_TYPE;
80   MPI_Datatype datatype2 = MPI_DEFAULT_TYPE;
81 };
82
83 class BcastArgParser : public CollCommParser {
84 public:
85   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
86 };
87
88 class ReduceArgParser : public CollCommParser {
89 public:
90   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
91 };
92
93 class AllReduceArgParser : public CollCommParser {
94 public:
95   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
96 };
97
98 class AllToAllArgParser : public CollCommParser {
99 public:
100   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
101 };
102
103 class GatherArgParser : public CollCommParser {
104 public:
105   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
106 };
107
108 class GatherVArgParser : public CollCommParser {
109 public:
110   int recv_size_sum;
111   std::shared_ptr<std::vector<int>> recvcounts;
112   std::vector<int> disps;
113   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
114 };
115
116 class ScatterArgParser : public CollCommParser {
117 public:
118   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
119 };
120
121 class ScatterVArgParser : public CollCommParser {
122 public:
123   int recv_size_sum;
124   int send_size_sum;
125   std::shared_ptr<std::vector<int>> sendcounts;
126   std::vector<int> disps;
127   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
128 };
129
130 class ReduceScatterArgParser : public CollCommParser {
131 public:
132   int recv_size_sum;
133   std::shared_ptr<std::vector<int>> recvcounts;
134   std::vector<int> disps;
135   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
136 };
137
138 class AllToAllVArgParser : public CollCommParser {
139 public:
140   int recv_size_sum;
141   int send_size_sum;
142   std::shared_ptr<std::vector<int>> recvcounts;
143   std::shared_ptr<std::vector<int>> sendcounts;
144   std::vector<int> senddisps;
145   std::vector<int> recvdisps;
146   int send_buf_size;
147   int recv_buf_size;
148   void parse(simgrid::xbt::ReplayAction& action, std::string name) override;
149 };
150
151 /**
152  * Base class for all ReplayActions.
153  * Note that this class actually implements the behavior of each action
154  * while the parsing of the replay arguments is done in the ActionArgParser class.
155  * In other words: The logic goes here, the setup is done by the ActionArgParser.
156  */
157 template <class T> class ReplayAction {
158 protected:
159   const std::string name;
160   const int my_proc_id;
161   T args;
162
163 public:
164   explicit ReplayAction(std::string name) : name(name), my_proc_id(simgrid::s4u::this_actor::get_pid()) {}
165   virtual ~ReplayAction() = default;
166
167   virtual void execute(simgrid::xbt::ReplayAction& action);
168   virtual void kernel(simgrid::xbt::ReplayAction& action) = 0;
169   void* send_buffer(int size) { return smpi_get_tmp_sendbuffer(size); }
170   void* recv_buffer(int size) { return smpi_get_tmp_recvbuffer(size); }
171 };
172
173 class WaitAction : public ReplayAction<WaitTestParser> {
174 private:
175   RequestStorage& req_storage;
176
177 public:
178   explicit WaitAction(RequestStorage& storage) : ReplayAction("Wait"), req_storage(storage) {}
179   void kernel(simgrid::xbt::ReplayAction& action) override;
180 };
181
182 class SendAction : public ReplayAction<SendRecvParser> {
183 private:
184   RequestStorage& req_storage;
185
186 public:
187   explicit SendAction(std::string name, RequestStorage& storage) : ReplayAction(name), req_storage(storage) {}
188   void kernel(simgrid::xbt::ReplayAction& action) override;
189 };
190
191 class RecvAction : public ReplayAction<SendRecvParser> {
192 private:
193   RequestStorage& req_storage;
194
195 public:
196   explicit RecvAction(std::string name, RequestStorage& storage) : ReplayAction(name), req_storage(storage) {}
197   void kernel(simgrid::xbt::ReplayAction& action) override;
198 };
199
200 class ComputeAction : public ReplayAction<ComputeParser> {
201 public:
202   explicit ComputeAction() : ReplayAction("compute") {}
203   void kernel(simgrid::xbt::ReplayAction& action) override;
204 };
205
206 class TestAction : public ReplayAction<WaitTestParser> {
207 private:
208   RequestStorage& req_storage;
209
210 public:
211   explicit TestAction(RequestStorage& storage) : ReplayAction("Test"), req_storage(storage) {}
212   void kernel(simgrid::xbt::ReplayAction& action) override;
213 };
214
215 class InitAction : public ReplayAction<ActionArgParser> {
216 public:
217   explicit InitAction() : ReplayAction("Init") {}
218   void kernel(simgrid::xbt::ReplayAction& action) override;
219 };
220
221 class CommunicatorAction : public ReplayAction<ActionArgParser> {
222 public:
223   explicit CommunicatorAction() : ReplayAction("Comm") {}
224   void kernel(simgrid::xbt::ReplayAction& action) override;
225 };
226
227 class WaitAllAction : public ReplayAction<ActionArgParser> {
228 private:
229   RequestStorage& req_storage;
230
231 public:
232   explicit WaitAllAction(RequestStorage& storage) : ReplayAction("waitAll"), req_storage(storage) {}
233   void kernel(simgrid::xbt::ReplayAction& action) override;
234 };
235
236 class BarrierAction : public ReplayAction<ActionArgParser> {
237 public:
238   explicit BarrierAction() : ReplayAction("barrier") {}
239   void kernel(simgrid::xbt::ReplayAction& action) override;
240 };
241
242 class BcastAction : public ReplayAction<BcastArgParser> {
243 public:
244   explicit BcastAction() : ReplayAction("bcast") {}
245   void kernel(simgrid::xbt::ReplayAction& action) override;
246 };
247
248 class ReduceAction : public ReplayAction<ReduceArgParser> {
249 public:
250   explicit ReduceAction() : ReplayAction("reduce") {}
251   void kernel(simgrid::xbt::ReplayAction& action) override;
252 };
253
254 class AllReduceAction : public ReplayAction<AllReduceArgParser> {
255 public:
256   explicit AllReduceAction() : ReplayAction("allReduce") {}
257   void kernel(simgrid::xbt::ReplayAction& action) override;
258 };
259
260 class AllToAllAction : public ReplayAction<AllToAllArgParser> {
261 public:
262   explicit AllToAllAction() : ReplayAction("allToAll") {}
263   void kernel(simgrid::xbt::ReplayAction& action) override;
264 };
265
266 class GatherAction : public ReplayAction<GatherArgParser> {
267 public:
268   explicit GatherAction(std::string name) : ReplayAction(name) {}
269   void kernel(simgrid::xbt::ReplayAction& action) override;
270 };
271
272 class GatherVAction : public ReplayAction<GatherVArgParser> {
273 public:
274   explicit GatherVAction(std::string name) : ReplayAction(name) {}
275   void kernel(simgrid::xbt::ReplayAction& action) override;
276 };
277
278 class ScatterAction : public ReplayAction<ScatterArgParser> {
279 public:
280   explicit ScatterAction() : ReplayAction("scatter") {}
281   void kernel(simgrid::xbt::ReplayAction& action) override;
282 };
283
284 class ScatterVAction : public ReplayAction<ScatterVArgParser> {
285 public:
286   explicit ScatterVAction() : ReplayAction("scatterV") {}
287   void kernel(simgrid::xbt::ReplayAction& action) override;
288 };
289
290 class ReduceScatterAction : public ReplayAction<ReduceScatterArgParser> {
291 public:
292   explicit ReduceScatterAction() : ReplayAction("reduceScatter") {}
293   void kernel(simgrid::xbt::ReplayAction& action) override;
294 };
295
296 class AllToAllVAction : public ReplayAction<AllToAllVArgParser> {
297 public:
298   explicit AllToAllVAction() : ReplayAction("allToAllV") {}
299   void kernel(simgrid::xbt::ReplayAction& action) override;
300 };
301 }
302 }
303 }