Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Unify input checking using shared macros. Avoid repeating code.
[simgrid.git] / src / smpi / bindings / smpi_pmpi_file.cpp
1 /* Copyright (c) 2007-2019. 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
6 #include "private.hpp"
7
8 #include "smpi_file.hpp"
9 #include "smpi_datatype.hpp"
10
11 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
12
13 extern MPI_Errhandler SMPI_default_File_Errhandler;
14
15 int PMPI_File_open(MPI_Comm comm, const char *filename, int amode, MPI_Info info, MPI_File *fh){
16   if (comm == MPI_COMM_NULL)
17     return MPI_ERR_COMM;
18   if (filename == nullptr)
19     return MPI_ERR_FILE;
20   if (amode < 0)
21     return MPI_ERR_AMODE;
22   smpi_bench_end();
23   *fh =  new simgrid::smpi::File(comm, filename, amode, info);
24   smpi_bench_begin();
25   if ((*fh)->size() != 0 && (amode & MPI_MODE_EXCL)){
26     delete fh;
27     return MPI_ERR_AMODE;
28   }
29   if(amode & MPI_MODE_APPEND)
30     (*fh)->seek(0,MPI_SEEK_END);
31   return MPI_SUCCESS;
32 }
33
34 int PMPI_File_close(MPI_File *fh){
35   if (fh==nullptr)
36     return MPI_ERR_ARG;
37   smpi_bench_end();
38   int ret = simgrid::smpi::File::close(fh);
39   *fh = MPI_FILE_NULL;
40   smpi_bench_begin();
41   return ret;
42 }
43
44
45 #define CHECK_OFFSET(offset)                                                                                           \
46   if ((offset) < 0)                                                                                                    \
47     return MPI_ERR_DISP;
48 #define CHECK_STATUS(status)                                                                                           \
49   if ((status) == nullptr)                                                                                             \
50     return MPI_ERR_ARG;
51 #define CHECK_FLAGS(fh)                                                                                                \
52   if ((fh)->flags() & MPI_MODE_SEQUENTIAL)                                                                             \
53     return MPI_ERR_AMODE;
54 #define CHECK_RDONLY(fh)                                                                                               \
55   if ((fh)->flags() & MPI_MODE_RDONLY)                                                                                 \
56     return MPI_ERR_AMODE;
57
58 #define PASS_ZEROCOUNT(count)                                                                                          \
59   if ((count) == 0) {                                                                                                  \
60     status->count = 0;                                                                                                 \
61     return MPI_SUCCESS;                                                                                                \
62   }
63
64 int PMPI_File_seek(MPI_File fh, MPI_Offset offset, int whence){
65   CHECK_FILE(1, fh)
66   smpi_bench_end();
67   int ret = fh->seek(offset,whence);
68   smpi_bench_begin();
69   return ret;
70 }
71
72 int PMPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence){
73   CHECK_FILE(1, fh)
74   smpi_bench_end();
75   int ret = fh->seek_shared(offset,whence);
76   smpi_bench_begin();
77   return ret;
78 }
79
80 int PMPI_File_get_position(MPI_File fh, MPI_Offset* offset){
81   if (offset==nullptr)
82     return MPI_ERR_DISP;
83   smpi_bench_end();
84   int ret = fh->get_position(offset);
85   smpi_bench_begin();
86   return ret;
87 }
88
89 int PMPI_File_get_position_shared(MPI_File fh, MPI_Offset* offset){
90   CHECK_FILE(1, fh)
91   if (offset==nullptr)
92     return MPI_ERR_DISP;
93   smpi_bench_end();
94   int ret = fh->get_position_shared(offset);
95   smpi_bench_begin();
96   return ret;
97 }
98
99 int PMPI_File_read(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
100   CHECK_FILE(1, fh)
101   CHECK_BUFFER(2, buf, count)
102   CHECK_COUNT(3, count)
103   CHECK_TYPE(4, datatype)
104   CHECK_STATUS(status)
105   CHECK_FLAGS(fh)
106   PASS_ZEROCOUNT(count)
107   smpi_bench_end();
108   int rank_traced = simgrid::s4u::this_actor::get_pid();
109   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
110   int ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
111   TRACE_smpi_comm_out(rank_traced);
112   smpi_bench_begin();
113   return ret;
114 }
115
116 int PMPI_File_read_shared(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
117   CHECK_FILE(1, fh)
118   CHECK_BUFFER(2, buf, count)
119   CHECK_COUNT(3, count)
120   CHECK_TYPE(4, datatype)
121   CHECK_STATUS(status)
122   CHECK_FLAGS(fh)
123   PASS_ZEROCOUNT(count)
124   smpi_bench_end();
125   int rank_traced = simgrid::s4u::this_actor::get_pid();
126   TRACE_smpi_comm_in(rank_traced, __func__,
127                      new simgrid::instr::CpuTIData("IO - read_shared", count * datatype->size()));
128   int ret = simgrid::smpi::File::read_shared(fh, buf, count, datatype, status);
129   TRACE_smpi_comm_out(rank_traced);
130   smpi_bench_begin();
131   return ret;
132 }
133
134 int PMPI_File_write(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
135   CHECK_FILE(1, fh)
136   CHECK_BUFFER(2, buf, count)
137   CHECK_COUNT(3, count)
138   CHECK_TYPE(4, datatype)
139   CHECK_STATUS(status)
140   CHECK_FLAGS(fh)
141   CHECK_RDONLY(fh)
142   PASS_ZEROCOUNT(count)
143   smpi_bench_end();
144   int rank_traced = simgrid::s4u::this_actor::get_pid();
145   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
146   int ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
147   TRACE_smpi_comm_out(rank_traced);
148   smpi_bench_begin();
149   return ret;
150 }
151
152 int PMPI_File_write_shared(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
153   CHECK_FILE(1, fh)
154   CHECK_BUFFER(2, buf, count)
155   CHECK_COUNT(3, count)
156   CHECK_TYPE(4, datatype)
157   CHECK_STATUS(status)
158   CHECK_FLAGS(fh)
159   CHECK_RDONLY(fh)
160   PASS_ZEROCOUNT(count)
161   smpi_bench_end();
162   int rank_traced = simgrid::s4u::this_actor::get_pid();
163   TRACE_smpi_comm_in(rank_traced, __func__,
164                      new simgrid::instr::CpuTIData("IO - write_shared", count * datatype->size()));
165   int ret = simgrid::smpi::File::write_shared(fh, buf, count, datatype, status);
166   TRACE_smpi_comm_out(rank_traced);
167   smpi_bench_begin();
168   return ret;
169 }
170
171 int PMPI_File_read_all(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
172   CHECK_FILE(1, fh)
173   CHECK_BUFFER(2, buf, count)
174   CHECK_COUNT(3, count)
175   CHECK_TYPE(4, datatype)
176   CHECK_STATUS(status)
177   CHECK_FLAGS(fh)
178   smpi_bench_end();
179   int rank_traced = simgrid::s4u::this_actor::get_pid();
180   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_all", count * datatype->size()));
181   int ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
182   TRACE_smpi_comm_out(rank_traced);
183   smpi_bench_begin();
184   return ret;
185 }
186
187 int PMPI_File_read_ordered(MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
188   CHECK_FILE(1, fh)
189   CHECK_BUFFER(2, buf, count)
190   CHECK_COUNT(3, count)
191   CHECK_TYPE(4, datatype)
192   CHECK_STATUS(status)
193   CHECK_FLAGS(fh)
194   smpi_bench_end();
195   int rank_traced = simgrid::s4u::this_actor::get_pid();
196   TRACE_smpi_comm_in(rank_traced, __func__,
197                      new simgrid::instr::CpuTIData("IO - read_ordered", count * datatype->size()));
198   int ret = simgrid::smpi::File::read_ordered(fh, buf, count, datatype, status);
199   TRACE_smpi_comm_out(rank_traced);
200   smpi_bench_begin();
201   return ret;
202 }
203
204 int PMPI_File_write_all(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
205   CHECK_FILE(1, fh)
206   CHECK_BUFFER(2, buf, count)
207   CHECK_COUNT(3, count)
208   CHECK_TYPE(4, datatype)
209   CHECK_STATUS(status)
210   CHECK_FLAGS(fh)
211   CHECK_RDONLY(fh)
212   smpi_bench_end();
213   int rank_traced = simgrid::s4u::this_actor::get_pid();
214   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_all", count * datatype->size()));
215   int ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
216   TRACE_smpi_comm_out(rank_traced);
217   smpi_bench_begin();
218   return ret;
219 }
220
221 int PMPI_File_write_ordered(MPI_File fh, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
222   CHECK_FILE(1, fh)
223   CHECK_BUFFER(2, buf, count)
224   CHECK_COUNT(3, count)
225   CHECK_TYPE(4, datatype)
226   CHECK_STATUS(status)
227   CHECK_FLAGS(fh)
228   CHECK_RDONLY(fh)
229   smpi_bench_end();
230   int rank_traced = simgrid::s4u::this_actor::get_pid();
231   TRACE_smpi_comm_in(rank_traced, __func__,
232                      new simgrid::instr::CpuTIData("IO - write_ordered", count * datatype->size()));
233   int ret = simgrid::smpi::File::write_ordered(fh, buf, count, datatype, status);
234   TRACE_smpi_comm_out(rank_traced);
235   smpi_bench_begin();
236   return ret;
237 }
238
239 int PMPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
240   CHECK_FILE(1, fh)
241   CHECK_BUFFER(2, buf, count)
242   CHECK_OFFSET(offset)
243   CHECK_COUNT(3, count)
244   CHECK_TYPE(4, datatype)
245   CHECK_STATUS(status)
246   CHECK_FLAGS(fh)
247   PASS_ZEROCOUNT(count);
248   smpi_bench_end();
249   int rank_traced = simgrid::s4u::this_actor::get_pid();
250   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
251   int ret = fh->seek(offset,MPI_SEEK_SET);
252   if(ret!=MPI_SUCCESS)
253     return ret;
254   ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
255   TRACE_smpi_comm_out(rank_traced);
256   smpi_bench_begin();
257   return ret;
258 }
259
260 int PMPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
261   CHECK_FILE(1, fh)
262   CHECK_BUFFER(2, buf, count)
263   CHECK_OFFSET(offset)
264   CHECK_COUNT(3, count)
265   CHECK_TYPE(4, datatype)
266   CHECK_STATUS(status)
267   CHECK_FLAGS(fh)
268   smpi_bench_end();
269   int rank_traced = simgrid::s4u::this_actor::get_pid();
270   TRACE_smpi_comm_in(rank_traced, __func__,
271                      new simgrid::instr::CpuTIData("IO - read_at_all", count * datatype->size()));
272   int ret = fh->seek(offset,MPI_SEEK_SET);
273   if(ret!=MPI_SUCCESS)
274     return ret;
275   ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
276   TRACE_smpi_comm_out(rank_traced);
277   smpi_bench_begin();
278   return ret;
279 }
280
281 int PMPI_File_write_at(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
282   CHECK_FILE(1, fh)
283   CHECK_BUFFER(2, buf, count)
284   CHECK_OFFSET(offset)
285   CHECK_COUNT(4, count)
286   CHECK_TYPE(5, datatype)
287   CHECK_STATUS(status)
288   CHECK_FLAGS(fh)
289   CHECK_RDONLY(fh)
290   PASS_ZEROCOUNT(count);
291   smpi_bench_end();
292   int rank_traced = simgrid::s4u::this_actor::get_pid();
293   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
294   int ret = fh->seek(offset,MPI_SEEK_SET);
295   if(ret!=MPI_SUCCESS)
296     return ret;
297   ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
298   TRACE_smpi_comm_out(rank_traced);
299   smpi_bench_begin();
300   return ret;
301 }
302
303 int PMPI_File_write_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,MPI_Datatype datatype, MPI_Status *status){
304   CHECK_FILE(1, fh)
305   CHECK_BUFFER(2, buf, count)
306   CHECK_OFFSET(offset)
307   CHECK_COUNT(4, count)
308   CHECK_TYPE(5, datatype)
309   CHECK_STATUS(status)
310   CHECK_FLAGS(fh)
311   CHECK_RDONLY(fh)
312   smpi_bench_end();
313   int rank_traced = simgrid::s4u::this_actor::get_pid();
314   TRACE_smpi_comm_in(rank_traced, __func__,
315                      new simgrid::instr::CpuTIData("IO - write_at_all", count * datatype->size()));
316   int ret = fh->seek(offset,MPI_SEEK_SET);
317   if(ret!=MPI_SUCCESS)
318     return ret;
319   ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
320   TRACE_smpi_comm_out(rank_traced);
321   smpi_bench_begin();
322   return ret;
323 }
324
325 int PMPI_File_delete(const char *filename, MPI_Info info){
326   if (filename == nullptr)
327     return MPI_ERR_FILE;
328   smpi_bench_end();
329   int ret = simgrid::smpi::File::del(filename, info);
330   smpi_bench_begin();
331   return ret;
332 }
333
334 int PMPI_File_get_info(MPI_File  fh, MPI_Info* info)
335 {
336   CHECK_FILE(1, fh)
337   *info = fh->info();
338   return MPI_SUCCESS;
339 }
340
341 int PMPI_File_set_info(MPI_File  fh, MPI_Info info)
342 {
343   CHECK_FILE(1, fh)
344   fh->set_info(info);
345   return MPI_SUCCESS;
346 }
347
348 int PMPI_File_get_size(MPI_File  fh, MPI_Offset* size)
349 {
350   CHECK_FILE(1, fh)
351   *size = fh->size();
352   return MPI_SUCCESS;
353 }
354
355 int PMPI_File_get_amode(MPI_File  fh, int* amode)
356 {
357   CHECK_FILE(1, fh)
358   *amode = fh->flags();
359   return MPI_SUCCESS;
360 }
361
362 int PMPI_File_get_group(MPI_File  fh, MPI_Group* group)
363 {
364   CHECK_FILE(1, fh)
365   *group = fh->comm()->group();
366   return MPI_SUCCESS;
367 }
368
369 int PMPI_File_sync(MPI_File  fh)
370 {
371   CHECK_FILE(1, fh)
372   fh->sync();
373   return MPI_SUCCESS;
374 }
375
376 int PMPI_File_create_errhandler(MPI_File_errhandler_function* function, MPI_Errhandler* errhandler){
377   *errhandler=new simgrid::smpi::Errhandler(function);
378   return MPI_SUCCESS;
379 }
380
381 int PMPI_File_get_errhandler(MPI_File file, MPI_Errhandler* errhandler){
382   if (errhandler==nullptr){
383     return MPI_ERR_ARG;
384   } else if (file == MPI_FILE_NULL) {
385     *errhandler = SMPI_default_File_Errhandler;
386     return MPI_SUCCESS;
387   }
388   *errhandler=file->errhandler();
389   return MPI_SUCCESS;
390 }
391
392 int PMPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler){
393   if (errhandler==nullptr){
394     return MPI_ERR_ARG;
395   } else if (file == MPI_FILE_NULL) {
396     SMPI_default_File_Errhandler = errhandler;
397     return MPI_SUCCESS;
398   }
399   file->set_errhandler(errhandler);
400   return MPI_SUCCESS;
401 }
402
403 int PMPI_File_call_errhandler(MPI_File file,int errorcode){
404   if (file == nullptr) {
405     return MPI_ERR_WIN;
406   }
407   file->errhandler()->call(file, errorcode);
408   return MPI_SUCCESS;
409 }