Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
plug a huge memleak in regular communications
[simgrid.git] / src / simix / smx_network.cpp
1 /* Copyright (c) 2009-2017. 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 <algorithm>
7
8 #include <boost/range/algorithm.hpp>
9
10 #include "src/kernel/activity/CommImpl.hpp"
11 #include <xbt/ex.hpp>
12
13 #include "simgrid/s4u/Host.hpp"
14
15 #include "mc/mc.h"
16 #include "simgrid/s4u/Activity.hpp"
17 #include "simgrid/s4u/Mailbox.hpp"
18 #include "src/mc/mc_replay.h"
19 #include "src/simix/smx_private.h"
20 #include "src/surf/cpu_interface.hpp"
21 #include "src/surf/surf_interface.hpp"
22
23 #include "src/surf/network_interface.hpp"
24
25 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_network, simix, "SIMIX network-related synchronization");
26
27 static void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall);
28 static void SIMIX_comm_copy_data(smx_activity_t comm);
29 static void SIMIX_comm_start(smx_activity_t synchro);
30 static simgrid::kernel::activity::CommImpl*
31 _find_matching_comm(boost::circular_buffer_space_optimized<smx_activity_t>* deque, e_smx_comm_type_t type,
32                     int (*match_fun)(void*, void*, smx_activity_t), void* user_data, smx_activity_t my_synchro,
33                     bool remove_matching);
34
35 /**
36  *  \brief Checks if there is a communication activity queued in a deque matching our needs
37  *  \param type The type of communication we are looking for (comm_send, comm_recv)
38  *  \return The communication activity if found, nullptr otherwise
39  */
40 static simgrid::kernel::activity::CommImpl*
41 _find_matching_comm(boost::circular_buffer_space_optimized<smx_activity_t>* deque, e_smx_comm_type_t type,
42                     int (*match_fun)(void*, void*, smx_activity_t), void* this_user_data, smx_activity_t my_synchro,
43                     bool remove_matching)
44 {
45   void* other_user_data = nullptr;
46
47   for(auto it = deque->begin(); it != deque->end(); it++){
48     smx_activity_t synchro = *it;
49     simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
50
51     if (comm->type == SIMIX_COMM_SEND) {
52       other_user_data = comm->src_data;
53     } else if (comm->type == SIMIX_COMM_RECEIVE) {
54       other_user_data = comm->dst_data;
55     }
56     if (comm->type == type && (match_fun == nullptr || match_fun(this_user_data, other_user_data, synchro)) &&
57         (not comm->match_fun || comm->match_fun(other_user_data, this_user_data, my_synchro))) {
58       XBT_DEBUG("Found a matching communication synchro %p", comm);
59       if (remove_matching)
60         deque->erase(it);
61       SIMIX_comm_ref(comm);
62 #if SIMGRID_HAVE_MC
63       comm->mbox_cpy = comm->mbox;
64 #endif
65       comm->mbox = nullptr;
66       return comm;
67     }
68     XBT_DEBUG("Sorry, communication synchro %p does not match our needs:"
69               " its type is %d but we are looking for a comm of type %d (or maybe the filtering didn't match)",
70               comm, (int)comm->type, (int)type);
71   }
72   XBT_DEBUG("No matching communication synchro found");
73   return nullptr;
74 }
75
76 /******************************************************************************/
77 /*                          Communication synchros                            */
78 /******************************************************************************/
79 XBT_PRIVATE void simcall_HANDLER_comm_send(smx_simcall_t simcall, smx_actor_t src, smx_mailbox_t mbox,
80                                   double task_size, double rate,
81                                   void *src_buff, size_t src_buff_size,
82                                   int (*match_fun)(void *, void *,smx_activity_t),
83                                   void (*copy_data_fun)(smx_activity_t, void*, size_t),
84           void *data, double timeout){
85   smx_activity_t comm = simcall_HANDLER_comm_isend(simcall, src, mbox, task_size, rate,
86                            src_buff, src_buff_size, match_fun, nullptr, copy_data_fun,
87                data, 0);
88   SIMCALL_SET_MC_VALUE(simcall, 0);
89   simcall_HANDLER_comm_wait(simcall, comm, timeout);
90 }
91 XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t src_proc, smx_mailbox_t mbox,
92                                   double task_size, double rate,
93                                   void *src_buff, size_t src_buff_size,
94                                   int (*match_fun)(void *, void *,smx_activity_t),
95                                   void (*clean_fun)(void *), // used to free the synchro in case of problem after a detached send
96                                   void (*copy_data_fun)(smx_activity_t, void*, size_t),// used to copy data if not default one
97                           void *data, int detached)
98 {
99   XBT_DEBUG("send from %p", mbox);
100
101   /* Prepare a synchro describing us, so that it gets passed to the user-provided filter of other side */
102   simgrid::kernel::activity::CommImpl* this_comm = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_SEND);
103
104   /* Look for communication synchro matching our needs. We also provide a description of
105    * ourself so that the other side also gets a chance of choosing if it wants to match with us.
106    *
107    * If it is not found then push our communication into the rendez-vous point */
108   simgrid::kernel::activity::CommImpl* other_comm =
109       _find_matching_comm(&mbox->comm_queue, SIMIX_COMM_RECEIVE, match_fun, data, this_comm, /*remove_matching*/ true);
110
111   if (not other_comm) {
112     other_comm = this_comm;
113
114     if (mbox->permanent_receiver!=nullptr){
115       //this mailbox is for small messages, which have to be sent right now
116       other_comm->state   = SIMIX_READY;
117       other_comm->dst_proc=mbox->permanent_receiver.get();
118       other_comm          = static_cast<simgrid::kernel::activity::CommImpl*>(SIMIX_comm_ref(other_comm));
119       mbox->done_comm_queue.push_back(other_comm);
120       XBT_DEBUG("pushing a message into the permanent receive list %p, comm %p", mbox, &(other_comm));
121
122     }else{
123       mbox->push(this_comm);
124     }
125   } else {
126     XBT_DEBUG("Receive already pushed");
127     SIMIX_comm_unref(this_comm);
128
129     other_comm->state = SIMIX_READY;
130     other_comm->type = SIMIX_COMM_READY;
131
132   }
133   src_proc->comms.push_back(other_comm);
134
135   if (detached) {
136     other_comm->detached = true;
137     other_comm->clean_fun = clean_fun;
138   } else {
139     other_comm->clean_fun = nullptr;
140   }
141
142   /* Setup the communication synchro */
143   other_comm->src_proc = src_proc;
144   other_comm->task_size = task_size;
145   other_comm->rate = rate;
146   other_comm->src_buff = src_buff;
147   other_comm->src_buff_size = src_buff_size;
148   other_comm->src_data = data;
149
150   other_comm->match_fun = match_fun;
151   other_comm->copy_data_fun = copy_data_fun;
152
153
154   if (MC_is_active() || MC_record_replay_is_active()) {
155     other_comm->state = SIMIX_RUNNING;
156     return (detached ? nullptr : other_comm);
157   }
158
159   SIMIX_comm_start(other_comm);
160   return (detached ? nullptr : other_comm);
161 }
162
163 XBT_PRIVATE void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox,
164                          void *dst_buff, size_t *dst_buff_size,
165                          int (*match_fun)(void *, void *, smx_activity_t),
166                          void (*copy_data_fun)(smx_activity_t, void*, size_t),
167                          void *data, double timeout, double rate)
168 {
169   smx_activity_t comm = SIMIX_comm_irecv(receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
170   SIMCALL_SET_MC_VALUE(simcall, 0);
171   simcall_HANDLER_comm_wait(simcall, comm, timeout);
172 }
173
174 XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox,
175     void *dst_buff, size_t *dst_buff_size,
176     int (*match_fun)(void *, void *, smx_activity_t),
177     void (*copy_data_fun)(smx_activity_t, void*, size_t),
178     void *data, double rate)
179 {
180   return SIMIX_comm_irecv(receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
181 }
182
183 smx_activity_t SIMIX_comm_irecv(smx_actor_t dst_proc, smx_mailbox_t mbox, void *dst_buff, size_t *dst_buff_size,
184     int (*match_fun)(void *, void *, smx_activity_t),
185     void (*copy_data_fun)(smx_activity_t, void*, size_t), // used to copy data if not default one
186     void *data, double rate)
187 {
188   simgrid::kernel::activity::CommImpl* this_synchro = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_RECEIVE);
189   XBT_DEBUG("recv from %p %p. this_synchro=%p", mbox, &mbox->comm_queue, this_synchro);
190
191   simgrid::kernel::activity::CommImpl* other_comm;
192   //communication already done, get it inside the list of completed comms
193   if (mbox->permanent_receiver != nullptr && not mbox->done_comm_queue.empty()) {
194
195     XBT_DEBUG("We have a comm that has probably already been received, trying to match it, to skip the communication");
196     //find a match in the list of already received comms
197     other_comm = _find_matching_comm(&mbox->done_comm_queue, SIMIX_COMM_SEND, match_fun, data, this_synchro,
198                                      /*remove_matching*/ true);
199     //if not found, assume the receiver came first, register it to the mailbox in the classical way
200     if (not other_comm) {
201       XBT_DEBUG("We have messages in the permanent receive list, but not the one we are looking for, pushing request into list");
202       other_comm = this_synchro;
203       mbox->push(this_synchro);
204     } else {
205       if (other_comm->surf_comm && other_comm->remains() < 1e-12) {
206         XBT_DEBUG("comm %p has been already sent, and is finished, destroy it",other_comm);
207         other_comm->state = SIMIX_DONE;
208         other_comm->type = SIMIX_COMM_DONE;
209         other_comm->mbox = nullptr;
210       }
211       SIMIX_comm_unref(other_comm);
212       SIMIX_comm_unref(this_synchro);
213     }
214   } else {
215     /* Prepare a comm describing us, so that it gets passed to the user-provided filter of other side */
216
217     /* Look for communication activity matching our needs. We also provide a description of
218      * ourself so that the other side also gets a chance of choosing if it wants to match with us.
219      *
220      * If it is not found then push our communication into the rendez-vous point */
221     other_comm = _find_matching_comm(&mbox->comm_queue, SIMIX_COMM_SEND, match_fun, data, this_synchro,
222                                      /*remove_matching*/ true);
223
224     if (not other_comm) {
225       XBT_DEBUG("Receive pushed first %zu", mbox->comm_queue.size());
226       other_comm = this_synchro;
227       mbox->push(this_synchro);
228     } else {
229       XBT_DEBUG("Match my %p with the existing %p", this_synchro, other_comm);
230
231       other_comm = static_cast<simgrid::kernel::activity::CommImpl*>(other_comm);
232
233       other_comm->state = SIMIX_READY;
234       other_comm->type = SIMIX_COMM_READY;
235       SIMIX_comm_unref(this_synchro);
236       SIMIX_comm_unref(this_synchro);
237     }
238     dst_proc->comms.push_back(other_comm);
239   }
240
241   /* Setup communication synchro */
242   other_comm->dst_proc = dst_proc;
243   other_comm->dst_buff = dst_buff;
244   other_comm->dst_buff_size = dst_buff_size;
245   other_comm->dst_data = data;
246
247   if (rate > -1.0 && (other_comm->rate < 0.0 || rate < other_comm->rate))
248     other_comm->rate = rate;
249
250   other_comm->match_fun = match_fun;
251   other_comm->copy_data_fun = copy_data_fun;
252
253   if (MC_is_active() || MC_record_replay_is_active()) {
254     other_comm->state = SIMIX_RUNNING;
255     return other_comm;
256   }
257
258   SIMIX_comm_start(other_comm);
259   return other_comm;
260 }
261
262 smx_activity_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox,
263                                    int type, int src, int tag,
264                                    int (*match_fun)(void *, void *, smx_activity_t),
265                                    void *data){
266   return SIMIX_comm_iprobe(simcall->issuer, mbox, type, src, tag, match_fun, data);
267 }
268
269 smx_activity_t SIMIX_comm_iprobe(smx_actor_t dst_proc, smx_mailbox_t mbox, int type, int src,
270                               int tag, int (*match_fun)(void *, void *, smx_activity_t), void *data)
271 {
272   XBT_DEBUG("iprobe from %p %p", mbox, &mbox->comm_queue);
273   simgrid::kernel::activity::CommImpl* this_comm;
274   int smx_type;
275   if(type == 1){
276     this_comm = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_SEND);
277     smx_type = SIMIX_COMM_RECEIVE;
278   } else{
279     this_comm = new simgrid::kernel::activity::CommImpl(SIMIX_COMM_RECEIVE);
280     smx_type = SIMIX_COMM_SEND;
281   } 
282   smx_activity_t other_synchro=nullptr;
283   if (mbox->permanent_receiver != nullptr && not mbox->done_comm_queue.empty()) {
284     XBT_DEBUG("first check in the permanent recv mailbox, to see if we already got something");
285     other_synchro = _find_matching_comm(&mbox->done_comm_queue,
286       (e_smx_comm_type_t) smx_type, match_fun, data, this_comm,/*remove_matching*/false);
287   }
288   if (not other_synchro) {
289     XBT_DEBUG("check if we have more luck in the normal mailbox");
290     other_synchro = _find_matching_comm(&mbox->comm_queue,
291       (e_smx_comm_type_t) smx_type, match_fun, data, this_comm,/*remove_matching*/false);
292   }
293
294   if(other_synchro)
295     SIMIX_comm_unref(other_synchro);
296
297   SIMIX_comm_unref(this_comm);
298   return other_synchro;
299 }
300
301 void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t synchro, double timeout)
302 {
303   /* Associate this simcall to the wait synchro */
304   XBT_DEBUG("simcall_HANDLER_comm_wait, %p", synchro);
305
306   synchro->simcalls.push_back(simcall);
307   simcall->issuer->waiting_synchro = synchro;
308
309   if (MC_is_active() || MC_record_replay_is_active()) {
310     int idx = SIMCALL_GET_MC_VALUE(simcall);
311     if (idx == 0) {
312       synchro->state = SIMIX_DONE;
313     } else {
314       /* If we reached this point, the wait simcall must have a timeout */
315       /* Otherwise it shouldn't be enabled and executed by the MC */
316       if (timeout < 0.0)
317         THROW_IMPOSSIBLE;
318
319       simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
320       if (comm->src_proc == simcall->issuer)
321         comm->state = SIMIX_SRC_TIMEOUT;
322       else
323         comm->state = SIMIX_DST_TIMEOUT;
324     }
325
326     SIMIX_comm_finish(synchro);
327     return;
328   }
329
330   /* If the synchro has already finish perform the error handling, */
331   /* otherwise set up a waiting timeout on the right side          */
332   if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING) {
333     SIMIX_comm_finish(synchro);
334   } else { /* if (timeout >= 0) { we need a surf sleep action even when there is no timeout, otherwise surf won't tell us when the host fails */
335     surf_action_t sleep = simcall->issuer->host->pimpl_cpu->sleep(timeout);
336     sleep->setData(synchro);
337
338     simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
339     if (simcall->issuer == comm->src_proc)
340       comm->src_timeout = sleep;
341     else
342       comm->dst_timeout = sleep;
343   }
344 }
345
346 void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_activity_t synchro)
347 {
348   simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
349
350   if (MC_is_active() || MC_record_replay_is_active()){
351     simcall_comm_test__set__result(simcall, comm->src_proc && comm->dst_proc);
352     if (simcall_comm_test__get__result(simcall)){
353       synchro->state = SIMIX_DONE;
354       synchro->simcalls.push_back(simcall);
355       SIMIX_comm_finish(synchro);
356     } else {
357       SIMIX_simcall_answer(simcall);
358     }
359     return;
360   }
361
362   simcall_comm_test__set__result(simcall, (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING));
363   if (simcall_comm_test__get__result(simcall)) {
364     synchro->simcalls.push_back(simcall);
365     SIMIX_comm_finish(synchro);
366   } else {
367     SIMIX_simcall_answer(simcall);
368   }
369 }
370
371 void simcall_HANDLER_comm_testany(
372   smx_simcall_t simcall, simgrid::kernel::activity::ActivityImpl* comms[], size_t count)
373 {
374   // The default result is -1 -- this means, "nothing is ready".
375   // It can be changed below, but only if something matches.
376   simcall_comm_testany__set__result(simcall, -1);
377
378   if (MC_is_active() || MC_record_replay_is_active()){
379     int idx = SIMCALL_GET_MC_VALUE(simcall);
380     if(idx == -1){
381       SIMIX_simcall_answer(simcall);
382     }else{
383       simgrid::kernel::activity::ActivityImpl* synchro = comms[idx];
384       simcall_comm_testany__set__result(simcall, idx);
385       synchro->simcalls.push_back(simcall);
386       synchro->state = SIMIX_DONE;
387       SIMIX_comm_finish(synchro);
388     }
389     return;
390   }
391
392   for (std::size_t i = 0; i != count; ++i) {
393     simgrid::kernel::activity::ActivityImpl* synchro = comms[i];
394     if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING) {
395       simcall_comm_testany__set__result(simcall, i);
396       synchro->simcalls.push_back(simcall);
397       SIMIX_comm_finish(synchro);
398       return;
399     }
400   }
401   SIMIX_simcall_answer(simcall);
402 }
403
404 void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t synchros, double timeout)
405 {
406   smx_activity_t synchro;
407   unsigned int cursor = 0;
408
409   if (MC_is_active() || MC_record_replay_is_active()){
410     if (timeout > 0.0)
411       xbt_die("Timeout not implemented for waitany in the model-checker"); 
412     int idx = SIMCALL_GET_MC_VALUE(simcall);
413     synchro = xbt_dynar_get_as(synchros, idx, smx_activity_t);
414     synchro->simcalls.push_back(simcall);
415     simcall_comm_waitany__set__result(simcall, idx);
416     synchro->state = SIMIX_DONE;
417     SIMIX_comm_finish(synchro);
418     return;
419   }
420   
421   if (timeout < 0.0){
422     simcall->timer = NULL;
423   } else {
424     simcall->timer = SIMIX_timer_set(SIMIX_get_clock() + timeout, [simcall]() {
425       SIMIX_waitany_remove_simcall_from_actions(simcall);
426       simcall_comm_waitany__set__result(simcall, -1);
427       SIMIX_simcall_answer(simcall);
428     });
429   }
430   
431   xbt_dynar_foreach(synchros, cursor, synchro){
432     /* associate this simcall to the the synchro */
433     synchro->simcalls.push_back(simcall);
434
435     /* see if the synchro is already finished */
436     if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING){
437       SIMIX_comm_finish(synchro);
438       break;
439     }
440   }
441 }
442
443 void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall)
444 {
445   smx_activity_t synchro;
446   unsigned int cursor = 0;
447   xbt_dynar_t synchros = simcall_comm_waitany__get__comms(simcall);
448
449   xbt_dynar_foreach(synchros, cursor, synchro) {
450     // Remove the first occurence of simcall:
451     auto i = boost::range::find(synchro->simcalls, simcall);
452     if (i !=  synchro->simcalls.end())
453       synchro->simcalls.erase(i);
454   }
455 }
456
457 /**
458  *  \brief Starts the simulation of a communication synchro.
459  *  \param synchro the communication synchro
460  */
461 static inline void SIMIX_comm_start(smx_activity_t synchro)
462 {
463   simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
464
465   /* If both the sender and the receiver are already there, start the communication */
466   if (synchro->state == SIMIX_READY) {
467
468     simgrid::s4u::Host* sender   = comm->src_proc->host;
469     simgrid::s4u::Host* receiver = comm->dst_proc->host;
470
471     comm->surf_comm = surf_network_model->communicate(sender, receiver, comm->task_size, comm->rate);
472     comm->surf_comm->setData(synchro);
473     comm->state = SIMIX_RUNNING;
474
475     XBT_DEBUG("Starting communication %p from '%s' to '%s' (surf_action: %p)", synchro, sender->cname(),
476               receiver->cname(), comm->surf_comm);
477
478     /* If a link is failed, detect it immediately */
479     if (comm->surf_comm->getState() == simgrid::surf::Action::State::failed) {
480       XBT_DEBUG("Communication from '%s' to '%s' failed to start because of a link failure", sender->cname(),
481                 receiver->cname());
482       comm->state = SIMIX_LINK_FAILURE;
483       comm->cleanupSurf();
484     }
485
486     /* If any of the process is suspend, create the synchro but stop its execution,
487        it will be restarted when the sender process resume */
488     if (SIMIX_process_is_suspended(comm->src_proc) || SIMIX_process_is_suspended(comm->dst_proc)) {
489       if (SIMIX_process_is_suspended(comm->src_proc))
490         XBT_DEBUG("The communication is suspended on startup because src (%s@%s) was suspended since it initiated the "
491                   "communication",
492                   comm->src_proc->cname(), comm->src_proc->host->cname());
493       else
494         XBT_DEBUG("The communication is suspended on startup because dst (%s@%s) was suspended since it initiated the "
495                   "communication",
496                   comm->dst_proc->cname(), comm->dst_proc->host->cname());
497
498       comm->surf_comm->suspend();
499     }
500   }
501 }
502
503 /**
504  * \brief Answers the SIMIX simcalls associated to a communication synchro.
505  * \param synchro a finished communication synchro
506  */
507 void SIMIX_comm_finish(smx_activity_t synchro)
508 {
509   simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
510
511   while (not synchro->simcalls.empty()) {
512     smx_simcall_t simcall = synchro->simcalls.front();
513     synchro->simcalls.pop_front();
514
515     /* If a waitany simcall is waiting for this synchro to finish, then remove it from the other synchros in the waitany
516      * list. Afterwards, get the position of the actual synchro in the waitany dynar and return it as the result of the
517      * simcall */
518
519     if (simcall->call == SIMCALL_NONE) //FIXME: maybe a better way to handle this case
520       continue; // if process handling comm is killed
521     if (simcall->call == SIMCALL_COMM_WAITANY) {
522       SIMIX_waitany_remove_simcall_from_actions(simcall);
523       if (simcall->timer) {
524         SIMIX_timer_remove(simcall->timer);
525         simcall->timer = nullptr;
526       }
527       if (not MC_is_active() && not MC_record_replay_is_active())
528         simcall_comm_waitany__set__result(simcall,
529                                           xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro));
530     }
531
532     /* If the synchro is still in a rendez-vous point then remove from it */
533     if (comm->mbox)
534       comm->mbox->remove(comm);
535
536     XBT_DEBUG("SIMIX_comm_finish: synchro state = %d", (int)synchro->state);
537
538     /* Check out for errors */
539
540     if (simcall->issuer->host->isOff()) {
541       simcall->issuer->context->iwannadie = 1;
542       SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
543     } else {
544       switch (comm->state) {
545
546         case SIMIX_DONE:
547           XBT_DEBUG("Communication %p complete!", synchro);
548           SIMIX_comm_copy_data(synchro);
549           break;
550
551         case SIMIX_SRC_TIMEOUT:
552           SMX_EXCEPTION(simcall->issuer, timeout_error, 0, "Communication timeouted because of sender");
553           break;
554
555         case SIMIX_DST_TIMEOUT:
556           SMX_EXCEPTION(simcall->issuer, timeout_error, 0, "Communication timeouted because of receiver");
557           break;
558
559         case SIMIX_SRC_HOST_FAILURE:
560           if (simcall->issuer == comm->src_proc)
561             simcall->issuer->context->iwannadie = 1;
562           //          SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
563           else
564             SMX_EXCEPTION(simcall->issuer, network_error, 0, "Remote peer failed");
565           break;
566
567         case SIMIX_DST_HOST_FAILURE:
568           if (simcall->issuer == comm->dst_proc)
569             simcall->issuer->context->iwannadie = 1;
570           //          SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
571           else
572             SMX_EXCEPTION(simcall->issuer, network_error, 0, "Remote peer failed");
573           break;
574
575         case SIMIX_LINK_FAILURE:
576           XBT_DEBUG("Link failure in synchro %p between '%s' and '%s': posting an exception to the issuer: %s (%p) "
577                     "detached:%d",
578                     synchro, comm->src_proc ? comm->src_proc->host->cname() : nullptr,
579                     comm->dst_proc ? comm->dst_proc->host->cname() : nullptr, simcall->issuer->cname(), simcall->issuer,
580                     comm->detached);
581           if (comm->src_proc == simcall->issuer) {
582             XBT_DEBUG("I'm source");
583           } else if (comm->dst_proc == simcall->issuer) {
584             XBT_DEBUG("I'm dest");
585           } else {
586             XBT_DEBUG("I'm neither source nor dest");
587           }
588           SMX_EXCEPTION(simcall->issuer, network_error, 0, "Link failure");
589           break;
590
591         case SIMIX_CANCELED:
592           if (simcall->issuer == comm->dst_proc)
593             SMX_EXCEPTION(simcall->issuer, cancel_error, 0, "Communication canceled by the sender");
594           else
595             SMX_EXCEPTION(simcall->issuer, cancel_error, 0, "Communication canceled by the receiver");
596           break;
597
598         default:
599           xbt_die("Unexpected synchro state in SIMIX_comm_finish: %d", (int)synchro->state);
600       }
601     }
602
603     /* if there is an exception during a waitany or a testany, indicate the position of the failed communication */
604     if (simcall->issuer->exception) {
605       // In order to modify the exception we have to rethrow it:
606       try {
607         std::rethrow_exception(simcall->issuer->exception);
608       }
609       catch(xbt_ex& e) {
610         if (simcall->call == SIMCALL_COMM_WAITANY) {
611           e.value = xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro);
612         }
613         else if (simcall->call == SIMCALL_COMM_TESTANY) {
614           e.value = -1;
615           auto comms = simcall_comm_testany__get__comms(simcall);
616           auto count = simcall_comm_testany__get__count(simcall);
617           auto element = std::find(comms, comms + count, synchro);
618           if (element == comms + count)
619             e.value = -1;
620           else
621             e.value = element - comms;
622         }
623         simcall->issuer->exception = std::make_exception_ptr(e);
624       }
625       catch(...) {
626         // Nothing to do
627       }
628     }
629
630     if (simcall->issuer->host->isOff()) {
631       simcall->issuer->context->iwannadie = 1;
632     }
633
634     simcall->issuer->waiting_synchro = nullptr;
635     simcall->issuer->comms.remove(synchro);
636     if(comm->detached){
637       if(simcall->issuer == comm->src_proc){
638         if(comm->dst_proc)
639           comm->dst_proc->comms.remove(synchro);
640       }
641       else if(simcall->issuer == comm->dst_proc){
642         if(comm->src_proc)
643           comm->src_proc->comms.remove(synchro);
644       }
645       else{
646         comm->dst_proc->comms.remove(synchro);
647         comm->src_proc->comms.remove(synchro);
648       }
649     }
650
651     SIMIX_simcall_answer(simcall);
652   }
653 }
654
655 /******************************************************************************/
656 /*                    SIMIX_comm_copy_data callbacks                       */
657 /******************************************************************************/
658 static void (*SIMIX_comm_copy_data_callback) (smx_activity_t, void*, size_t) = &SIMIX_comm_copy_pointer_callback;
659
660 void SIMIX_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, size_t))
661 {
662   SIMIX_comm_copy_data_callback = callback;
663 }
664
665 void SIMIX_comm_copy_pointer_callback(smx_activity_t synchro, void* buff, size_t buff_size)
666 {
667   simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
668
669   xbt_assert((buff_size == sizeof(void *)), "Cannot copy %zu bytes: must be sizeof(void*)", buff_size);
670   *(void **) (comm->dst_buff) = buff;
671 }
672
673 void SIMIX_comm_copy_buffer_callback(smx_activity_t synchro, void* buff, size_t buff_size)
674 {
675   simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
676
677   XBT_DEBUG("Copy the data over");
678   memcpy(comm->dst_buff, buff, buff_size);
679   if (comm->detached) { // if this is a detached send, the source buffer was duplicated by SMPI sender to make the original buffer available to the application ASAP
680     xbt_free(buff);
681     comm->src_buff = nullptr;
682   }
683 }
684
685 /**
686  *  @brief Copy the communication data from the sender's buffer to the receiver's one
687  *  @param synchro The communication
688  */
689 void SIMIX_comm_copy_data(smx_activity_t synchro)
690 {
691   simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(synchro);
692
693   size_t buff_size = comm->src_buff_size;
694   /* If there is no data to copy then return */
695   if (not comm->src_buff || not comm->dst_buff || comm->copied)
696     return;
697
698   XBT_DEBUG("Copying comm %p data from %s (%p) -> %s (%p) (%zu bytes)", comm,
699             comm->src_proc ? comm->src_proc->host->cname() : "a finished process", comm->src_buff,
700             comm->dst_proc ? comm->dst_proc->host->cname() : "a finished process", comm->dst_buff, buff_size);
701
702   /* Copy at most dst_buff_size bytes of the message to receiver's buffer */
703   if (comm->dst_buff_size)
704     buff_size = MIN(buff_size, *(comm->dst_buff_size));
705
706   /* Update the receiver's buffer size to the copied amount */
707   if (comm->dst_buff_size)
708     *comm->dst_buff_size = buff_size;
709
710   if (buff_size > 0){
711       if(comm->copy_data_fun)
712         comm->copy_data_fun (comm, comm->src_buff, buff_size);
713       else
714         SIMIX_comm_copy_data_callback (comm, comm->src_buff, buff_size);
715   }
716
717   /* Set the copied flag so we copy data only once */
718   /* (this function might be called from both communication ends) */
719   comm->copied = 1;
720 }
721
722 /** Increase the refcount for this comm */
723 smx_activity_t SIMIX_comm_ref(smx_activity_t comm)
724 {
725   if (comm != nullptr)
726     intrusive_ptr_add_ref(comm);
727   return comm;
728 }
729
730 /** Decrease the refcount for this comm */
731 void SIMIX_comm_unref(smx_activity_t comm)
732 {
733   if (comm != nullptr)
734     intrusive_ptr_release(comm);
735 }