Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Abort : check input, and remove fixme... Actual implementations do the same
[simgrid.git] / src / smpi / bindings / smpi_pmpi.cpp
1 /* Copyright (c) 2007-2021. 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 #include "simgrid/instr.h"
8 #include "simgrid/s4u/Engine.hpp"
9 #include "simgrid/s4u/Host.hpp"
10 #include "simgrid/version.h"
11 #include "smpi_comm.hpp"
12 #include "smpi_datatype_derived.hpp"
13 #include "smpi_status.hpp"
14 #include "src/kernel/actor/ActorImpl.hpp"
15 #include "src/smpi/include/smpi_actor.hpp"
16
17 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_pmpi, smpi, "Logging specific to SMPI (pmpi)");
18
19 //this function need to be here because of the calls to smpi_bench
20 void TRACE_smpi_set_category(const char *category)
21 {
22   //need to end bench otherwise categories for execution tasks are wrong
23   smpi_bench_end();
24   if (category != nullptr) {
25     // declare category
26     TRACE_category(category);
27     smpi_process()->set_tracing_category(category);
28   }
29   //begin bench after changing process's category
30   smpi_bench_begin();
31 }
32
33 /* PMPI User level calls */
34
35 int PMPI_Init(int*, char***)
36 {
37   xbt_assert(simgrid::s4u::Engine::is_initialized(),
38              "Your MPI program was not properly initialized. The easiest is to use smpirun to start it.");
39
40   if(smpi_process()->initializing()){
41     XBT_WARN("SMPI is already initializing - MPI_Init called twice ?");
42     return MPI_ERR_OTHER;
43   }
44   if(smpi_process()->initialized()){
45     XBT_WARN("SMPI already initialized once - MPI_Init called twice ?");
46     return MPI_ERR_OTHER;
47   }
48   if(smpi_process()->finalized()){
49     XBT_WARN("SMPI already finalized");
50     return MPI_ERR_OTHER;
51   }
52
53   simgrid::smpi::ActorExt::init();
54   int rank_traced = simgrid::s4u::this_actor::get_pid();
55   TRACE_smpi_init(rank_traced, __func__);
56   smpi_bench_begin();
57   smpi_process()->mark_as_initialized();
58
59   smpi_mpi_init();
60
61   return MPI_SUCCESS;
62 }
63
64 int PMPI_Finalize()
65 {
66   smpi_bench_end();
67   int rank_traced = simgrid::s4u::this_actor::get_pid();
68   TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::NoOpTIData("finalize"));
69
70   smpi_process()->finalize();
71
72   TRACE_smpi_comm_out(rank_traced);
73   return MPI_SUCCESS;
74 }
75
76 int PMPI_Finalized(int* flag)
77 {
78   *flag=smpi_process()!=nullptr ? smpi_process()->finalized() : 0;
79   return MPI_SUCCESS;
80 }
81
82 int PMPI_Get_version (int *version,int *subversion){
83   *version = MPI_VERSION;
84   *subversion= MPI_SUBVERSION;
85   return MPI_SUCCESS;
86 }
87
88 int PMPI_Get_library_version (char *version,int *len){
89   snprintf(version, MPI_MAX_LIBRARY_VERSION_STRING, "SMPI Version %d.%d. Copyright The SimGrid Team 2007-2021",
90            SIMGRID_VERSION_MAJOR, SIMGRID_VERSION_MINOR);
91   *len = strlen(version) > MPI_MAX_LIBRARY_VERSION_STRING ? MPI_MAX_LIBRARY_VERSION_STRING : strlen(version);
92   return MPI_SUCCESS;
93 }
94
95 int PMPI_Init_thread(int* argc, char*** argv, int /*required*/, int* provided)
96 {
97   if (provided != nullptr) {
98     *provided = MPI_THREAD_SINGLE;
99   }
100   return MPI_Init(argc, argv);
101 }
102
103 int PMPI_Query_thread(int *provided)
104 {
105   if (provided == nullptr) {
106     return MPI_ERR_ARG;
107   } else {
108     *provided = MPI_THREAD_SINGLE;
109     return MPI_SUCCESS;
110   }
111 }
112
113 int PMPI_Is_thread_main(int *flag)
114 {
115   // FIXME: The MPI standard seems to say that fatal errors need to be triggered
116   // if MPI has been finalized or not yet been initialized
117   if (flag == nullptr) {
118     return MPI_ERR_ARG;
119   } else {
120     *flag = simgrid::s4u::this_actor::get_pid() ==
121             1; // FIXME: I don't think this is correct: This just returns true if the process ID is 1,
122                // regardless of whether this process called MPI_Thread_Init() or not.
123     return MPI_SUCCESS;
124   }
125 }
126
127 int PMPI_Abort(MPI_Comm comm, int /*errorcode*/)
128 {
129   smpi_bench_end();
130   CHECK_COMM(1)
131   // Should kill all processes in comm instead.. but most real implementations also kill everything at this point
132   XBT_WARN("MPI_Abort was called, something went probably wrong in this simulation ! Killing this process");
133   smx_actor_t actor = SIMIX_process_self();
134   simgrid::kernel::actor::simcall([actor] { actor->exit(); });
135   return MPI_SUCCESS;
136 }
137
138 double PMPI_Wtime()
139 {
140   return smpi_mpi_wtime();
141 }
142
143 extern double sg_maxmin_precision;
144 double PMPI_Wtick()
145 {
146   return sg_maxmin_precision;
147 }
148
149 int PMPI_Address(const void* location, MPI_Aint* address)
150 {
151   if (address==nullptr) {
152     return MPI_ERR_ARG;
153   } else {
154     *address = reinterpret_cast<MPI_Aint>(location);
155     return MPI_SUCCESS;
156   }
157 }
158
159 int PMPI_Get_address(const void *location, MPI_Aint * address)
160 {
161   return PMPI_Address(location, address);
162 }
163
164 MPI_Aint PMPI_Aint_add(MPI_Aint address, MPI_Aint disp)
165 {
166   xbt_assert(address <= PTRDIFF_MAX - disp, "overflow in MPI_Aint_add");
167   return address + disp;
168 }
169
170 MPI_Aint PMPI_Aint_diff(MPI_Aint address, MPI_Aint disp)
171 {
172   xbt_assert(address >= PTRDIFF_MIN + disp, "underflow in MPI_Aint_diff");
173   return address - disp;
174 }
175
176 int PMPI_Get_processor_name(char *name, int *resultlen)
177 {
178   int len = std::min<int>(sg_host_self()->get_name().size(), MPI_MAX_PROCESSOR_NAME - 1);
179   std::string(sg_host_self()->get_name()).copy(name, len);
180   name[len]  = '\0';
181   *resultlen = len;
182
183   return MPI_SUCCESS;
184 }
185
186 int PMPI_Get_count(const MPI_Status * status, MPI_Datatype datatype, int *count)
187 {
188   if (status == nullptr || count == nullptr) {
189     return MPI_ERR_ARG;
190   } else if (not datatype->is_valid()) {
191     return MPI_ERR_TYPE;
192   } else {
193     size_t size = datatype->size();
194     if (size == 0) {
195       *count = 0;
196     } else if (status->count % size != 0) {
197       *count = MPI_UNDEFINED;
198     } else {
199       *count = simgrid::smpi::Status::get_count(status, datatype);
200     }
201     return MPI_SUCCESS;
202   }
203 }
204
205 int PMPI_Initialized(int* flag) {
206    *flag=(smpi_process()!=nullptr && smpi_process()->initialized());
207    return MPI_SUCCESS;
208 }
209
210 int PMPI_Alloc_mem(MPI_Aint size, MPI_Info /*info*/, void* baseptr)
211 {
212   void *ptr = xbt_malloc(size);
213   *static_cast<void**>(baseptr) = ptr;
214   return MPI_SUCCESS;
215 }
216
217 int PMPI_Free_mem(void *baseptr){
218   xbt_free(baseptr);
219   return MPI_SUCCESS;
220 }
221
222 int PMPI_Error_class(int errorcode, int* errorclass) {
223   // assume smpi uses only standard mpi error codes
224   *errorclass=errorcode;
225   return MPI_SUCCESS;
226 }
227
228 int PMPI_Error_string(int errorcode, char* string, int* resultlen)
229 {
230   static const std::vector<const char*> smpi_error_string = {FOREACH_ERROR(GENERATE_STRING)};
231   if (errorcode < 0 || static_cast<size_t>(errorcode) >= smpi_error_string.size() || string == nullptr)
232     return MPI_ERR_ARG;
233
234   int len    = snprintf(string, MPI_MAX_ERROR_STRING, "%s", smpi_error_string[errorcode]);
235   *resultlen = std::min(len, MPI_MAX_ERROR_STRING - 1);
236   return MPI_SUCCESS;
237 }
238
239 int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) {
240   smpi_copy_fn _copy_fn={copy_fn,nullptr,nullptr,nullptr,nullptr,nullptr};
241   smpi_delete_fn _delete_fn={delete_fn,nullptr,nullptr,nullptr,nullptr,nullptr};
242   return simgrid::smpi::Keyval::keyval_create<simgrid::smpi::Comm>(_copy_fn, _delete_fn, keyval, extra_state);
243 }
244
245 int PMPI_Keyval_free(int* keyval) {
246   return simgrid::smpi::Keyval::keyval_free<simgrid::smpi::Comm>(keyval);
247 }
248
249 MPI_Errhandler PMPI_Errhandler_f2c(MPI_Fint errhan){
250   if(errhan==-1)
251     return MPI_ERRHANDLER_NULL;
252   return simgrid::smpi::Errhandler::f2c(errhan);
253 }
254
255 MPI_Fint PMPI_Errhandler_c2f(MPI_Errhandler errhan){
256   if(errhan==MPI_ERRHANDLER_NULL)
257     return -1;
258   return errhan->c2f();
259 }
260
261 int PMPI_Buffer_attach(void *buf, int size){
262   if(buf==nullptr)
263     return MPI_ERR_BUFFER;
264   if(size<0)
265     return MPI_ERR_ARG;
266   return smpi_process()->set_bsend_buffer(buf, size);
267 }
268
269 int PMPI_Buffer_detach(void* buffer, int* size){
270   smpi_process()->bsend_buffer((void**)buffer, size);
271   return smpi_process()->set_bsend_buffer(nullptr, 0);
272 }