Specialize parameter for simcall comm_waitany.

diff --git a/include/simgrid/simix.h b/include/simgrid/simix.h
index c671930..a489689 100644 (file)
--- a/include/simgrid/simix.h
+++ b/include/simgrid/simix.h
@@ -226,7 +226,7 @@ XBT_PUBLIC smx_activity_t simcall_comm_iprobe(smx_mailbox_t mbox, int type,
                                               void* data);
 
 /* FIXME: waitany is going to be a vararg function, and should take a timeout */
-XBT_PUBLIC unsigned int simcall_comm_waitany(smx_activity_t* comms, size_t count, double timeout);
+XBT_PUBLIC unsigned int simcall_comm_waitany(smx_activity_t comms[], size_t count, double timeout);
 XBT_PUBLIC void simcall_comm_wait(const smx_activity_t& comm, double timeout);
 XBT_PUBLIC int simcall_comm_test(const smx_activity_t& comm);
 XBT_PUBLIC int simcall_comm_testany(smx_activity_t comms[], size_t count);

diff --git a/src/kernel/activity/CommImpl.cpp b/src/kernel/activity/CommImpl.cpp
index deb61c1..5af5025 100644 (file)
--- a/src/kernel/activity/CommImpl.cpp
+++ b/src/kernel/activity/CommImpl.cpp
@@ -286,28 +286,29 @@ void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activi
 
 static void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall)
 {
-  smx_activity_t* synchros = simcall_comm_waitany__get__comms(simcall);
-  size_t count             = simcall_comm_waitany__get__count(simcall);
+  simgrid::kernel::activity::CommImpl** comms = simcall_comm_waitany__get__comms(simcall);
+  size_t count                                = simcall_comm_waitany__get__count(simcall);
 
   for (size_t i = 0; i < count; i++) {
     // Remove the first occurence of simcall:
-    smx_activity_t& synchro = synchros[i];
-    auto j                  = boost::range::find(synchro->simcalls_, simcall);
-    if (j != synchro->simcalls_.end())
-      synchro->simcalls_.erase(j);
+    auto* comm = comms[i];
+    auto j     = boost::range::find(comm->simcalls_, simcall);
+    if (j != comm->simcalls_.end())
+      comm->simcalls_.erase(j);
   }
 }
-void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, smx_activity_t* synchros, size_t count, double timeout)
+void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comms[], size_t count,
+                                  double timeout)
 {
   if (MC_is_active() || MC_record_replay_is_active()) {
     if (timeout > 0.0)
       xbt_die("Timeout not implemented for waitany in the model-checker");
     int idx                 = SIMCALL_GET_MC_VALUE(simcall);
-    smx_activity_t& synchro = synchros[idx];
-    synchro->simcalls_.push_back(simcall);
+    auto* comm              = comms[idx];
+    comm->simcalls_.push_back(simcall);
     simcall_comm_waitany__set__result(simcall, idx);
-    synchro->state_ = SIMIX_DONE;
-    synchro->finish();
+    comm->state_ = SIMIX_DONE;
+    comm->finish();
     return;
   }
 
@@ -323,12 +324,12 @@ void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, smx_activity_t* synchro
 
   for (size_t i = 0; i < count; i++) {
     /* associate this simcall to the the synchro */
-    smx_activity_t& synchro = synchros[i];
-    synchro->simcalls_.push_back(simcall);
+    auto* comm = comms[i];
+    comm->simcalls_.push_back(simcall);
 
     /* see if the synchro is already finished */
-    if (synchro->state_ != SIMIX_WAITING && synchro->state_ != SIMIX_RUNNING) {
-      synchro->finish();
+    if (comm->state_ != SIMIX_WAITING && comm->state_ != SIMIX_RUNNING) {
+      comm->finish();
       break;
     }
   }

diff --git a/src/mc/mc_base.cpp b/src/mc/mc_base.cpp
index 788fca5..83a39e4 100644 (file)
--- a/src/mc/mc_base.cpp
+++ b/src/mc/mc_base.cpp
@@ -102,10 +102,10 @@ bool actor_is_enabled(smx_actor_t actor)
     }
 
     case SIMCALL_COMM_WAITANY: {
-      simgrid::kernel::activity::ActivityImpl** comms = simcall_comm_waitany__getraw__comms(req);
-      size_t count                                    = simcall_comm_waitany__get__count(req);
+      simgrid::kernel::activity::CommImpl** comms = simcall_comm_waitany__get__comms(req);
+      size_t count                                = simcall_comm_waitany__get__count(req);
       for (unsigned int index = 0; index < count; ++index) {
-        simgrid::kernel::activity::CommImpl* comm = static_cast<simgrid::kernel::activity::CommImpl*>(comms[index]);
+        auto* comm = comms[index];
         if (comm->src_actor_ && comm->dst_actor_)
           return true;
       }

diff --git a/src/mc/mc_request.cpp b/src/mc/mc_request.cpp
index 2eec09d..18c4014 100644 (file)
--- a/src/mc/mc_request.cpp
+++ b/src/mc/mc_request.cpp
@@ -302,8 +302,8 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
     type = "WaitAny";
     size_t count = simcall_comm_waitany__get__count(req);
     if (count > 0) {
-      simgrid::kernel::activity::ActivityImpl* remote_sync;
-      remote_sync = mc_model_checker->process().read(remote(simcall_comm_waitany__getraw__comms(req) + value));
+      simgrid::kernel::activity::CommImpl* remote_sync;
+      remote_sync = mc_model_checker->process().read(remote(simcall_comm_waitany__get__comms(req) + value));
       char* p     = pointer_to_string(remote_sync);
       args        = bprintf("comm=%s (%d of %zu)", p, value + 1, count);
       xbt_free(p);
@@ -373,7 +373,7 @@ namespace mc {
 
 bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
 {
-  simgrid::kernel::activity::ActivityImpl* remote_act = nullptr;
+  simgrid::kernel::activity::CommImpl* remote_act = nullptr;
   switch (req->call) {
 
   case SIMCALL_COMM_WAIT:
@@ -382,7 +382,7 @@ bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
     break;
 
   case SIMCALL_COMM_WAITANY:
-    remote_act = mc_model_checker->process().read(remote(simcall_comm_testany__getraw__comms(req) + idx));
+    remote_act = mc_model_checker->process().read(remote(simcall_comm_testany__get__comms(req) + idx));
     break;
 
   case SIMCALL_COMM_TESTANY:
@@ -394,7 +394,7 @@ bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
   }
 
   simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
-  mc_model_checker->process().read(temp_comm, remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_act)));
+  mc_model_checker->process().read(temp_comm, remote(remote_act));
   simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
   return comm->src_actor_.get() && comm->dst_actor_.get();
 }

diff --git a/src/mc/mc_state.cpp b/src/mc/mc_state.cpp
index 68440e0..f5d1ce8 100644 (file)
--- a/src/mc/mc_state.cpp
+++ b/src/mc/mc_state.cpp
@@ -152,11 +152,10 @@ static inline smx_simcall_t MC_state_get_request_for_process(simgrid::mc::State*
   switch (req->call) {
   case SIMCALL_COMM_WAITANY: {
     state->internal_req.call = SIMCALL_COMM_WAIT;
-    simgrid::kernel::activity::ActivityImpl* remote_comm;
+    simgrid::kernel::activity::CommImpl* remote_comm;
     remote_comm =
-        mc_model_checker->process().read(remote(simcall_comm_waitany__getraw__comms(req) + state->transition.argument));
-    mc_model_checker->process().read(state->internal_comm,
-                                     remote(static_cast<simgrid::kernel::activity::CommImpl*>(remote_comm)));
+        mc_model_checker->process().read(remote(simcall_comm_waitany__get__comms(req) + state->transition.argument));
+    mc_model_checker->process().read(state->internal_comm, remote(remote_comm));
     simcall_comm_wait__set__comm(&state->internal_req, state->internal_comm.getBuffer());
     simcall_comm_wait__set__timeout(&state->internal_req, 0);
     break;

diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp
index c7f7d2c..1da03e0 100644 (file)
--- a/src/simix/libsmx.cpp
+++ b/src/simix/libsmx.cpp
@@ -215,9 +215,13 @@ smx_activity_t simcall_comm_iprobe(smx_mailbox_t mbox, int type,
 /**
  * @ingroup simix_comm_management
  */
-unsigned int simcall_comm_waitany(smx_activity_t* comms, size_t count, double timeout)
+unsigned int simcall_comm_waitany(smx_activity_t comms[], size_t count, double timeout)
 {
-  return simcall_BODY_comm_waitany(comms, count, timeout);
+  std::unique_ptr<simgrid::kernel::activity::CommImpl* []> rcomms(new simgrid::kernel::activity::CommImpl*[count]);
+  std::transform(comms, comms + count, rcomms.get(), [](const smx_activity_t& comm) {
+    return static_cast<simgrid::kernel::activity::CommImpl*>(comm.get());
+  });
+  return simcall_BODY_comm_waitany(rcomms.get(), count, timeout);
 }
 
 /**
@@ -228,7 +232,7 @@ int simcall_comm_testany(smx_activity_t comms[], size_t count)
   if (count == 0)
     return -1;
   std::unique_ptr<simgrid::kernel::activity::CommImpl* []> rcomms(new simgrid::kernel::activity::CommImpl*[count]);
-  std::transform(comms, comms + count, rcomms.get(), [](const smx_activity_t comm) {
+  std::transform(comms, comms + count, rcomms.get(), [](const smx_activity_t& comm) {
     return static_cast<simgrid::kernel::activity::CommImpl*>(comm.get());
   });
   return simcall_BODY_comm_testany(rcomms.get(), count);

diff --git a/src/simix/popping_accessors.hpp b/src/simix/popping_accessors.hpp
index 50de5c8..0d92249 100644 (file)
--- a/src/simix/popping_accessors.hpp
+++ b/src/simix/popping_accessors.hpp
@@ -626,19 +626,17 @@ static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, boost:
   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 }
 
-static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*
-simcall_comm_waitany__get__comms(smx_simcall_t simcall)
+static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__get__comms(smx_simcall_t simcall)
 {
-  return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
+  return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl**>(simcall->args[0]);
 }
-static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
+static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
 {
-  return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
+  return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl**>(simcall->args[0]);
 }
-static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall,
-                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
+static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** arg)
 {
-  simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
+  simgrid::simix::marshal<simgrid::kernel::activity::CommImpl**>(simcall->args[0], arg);
 }
 static inline size_t simcall_comm_waitany__get__count(smx_simcall_t simcall)
 {
@@ -1038,8 +1036,7 @@ XBT_PRIVATE void simcall_HANDLER_comm_send(smx_simcall_t simcall, smx_actor_t se
 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, int detached);
 XBT_PRIVATE void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout, double rate);
 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double rate);
-XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall,
-                                              boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms,
+XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** comms,
                                               size_t count, double timeout);
 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm,
                                            double timeout);

diff --git a/src/simix/popping_bodies.cpp b/src/simix/popping_bodies.cpp
index 894e575..17dfef1 100644 (file)
--- a/src/simix/popping_bodies.cpp
+++ b/src/simix/popping_bodies.cpp
@@ -99,13 +99,12 @@ inline static boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simc
   return simcall<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>, smx_actor_t, smx_mailbox_t, void*, size_t*, simix_match_func_t, simix_copy_data_func_t, void*, double>(SIMCALL_COMM_IRECV, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
 }
 
-inline static int simcall_BODY_comm_waitany(boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms,
-                                            size_t count, double timeout)
+inline static int simcall_BODY_comm_waitany(simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout)
 {
   if (0) /* Go to that function to follow the code flow through the simcall barrier */
     simcall_HANDLER_comm_waitany(&SIMIX_process_self()->simcall, comms, count, timeout);
-  return simcall<int, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*, size_t, double>(
-      SIMCALL_COMM_WAITANY, comms, count, timeout);
+  return simcall<int, simgrid::kernel::activity::CommImpl**, size_t, double>(SIMCALL_COMM_WAITANY, comms, count,
+                                                                             timeout);
 }
 
 inline static void simcall_BODY_comm_wait(simgrid::kernel::activity::CommImpl* comm, double timeout)

diff --git a/src/simix/popping_generated.cpp b/src/simix/popping_generated.cpp
index bba0c71..1d7194f 100644 (file)
--- a/src/simix/popping_generated.cpp
+++ b/src/simix/popping_generated.cpp
@@ -106,8 +106,7 @@ case SIMCALL_COMM_IRECV:
 
 case SIMCALL_COMM_WAITANY:
   simcall_HANDLER_comm_waitany(
-      simcall,
-      simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]),
+      simcall, simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl**>(simcall->args[0]),
       simgrid::simix::unmarshal<size_t>(simcall->args[1]), simgrid::simix::unmarshal<double>(simcall->args[2]));
   break;
 

diff --git a/src/simix/simcalls.in b/src/simix/simcalls.in
index 534a973..a657616 100644 (file)
--- a/src/simix/simcalls.in
+++ b/src/simix/simcalls.in
@@ -46,7 +46,7 @@ void           comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_siz
 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm_isend(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, int detached);
 void           comm_recv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout, double rate) [[block]];
 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm_irecv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double rate);
-int            comm_waitany(boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms, size_t count, double timeout) [[block]];
+int            comm_waitany(simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout) [[block]];
 void           comm_wait(simgrid::kernel::activity::CommImpl* comm, double timeout) [[block]];
 int            comm_test(simgrid::kernel::activity::CommImpl* comm) [[block]];
 int            comm_testany(simgrid::kernel::activity::CommImpl** comms, size_t count) [[block]];