Stop using default mpi_call

diff --git a/src/deprecated.cpp b/src/deprecated.cpp
index 0881f54..7ea584c 100644 (file)
--- a/src/deprecated.cpp
+++ b/src/deprecated.cpp
@@ -44,7 +44,7 @@ simcall_comm_isend(simgrid::kernel::actor::ActorImpl* sender, simgrid::kernel::a
 
   simgrid::kernel::actor::CommIsendSimcall observer(sender, mbox, task_size, rate,
                                                     static_cast<unsigned char*>(src_buff), src_buff_size, match_fun,
-                                                    clean_fun, copy_data_fun, data, detached);
+                                                    clean_fun, copy_data_fun, data, detached, "Isend");
   return simgrid::kernel::actor::simcall_answered(
       [&observer] { return simgrid::kernel::activity::CommImpl::isend(&observer); });
 }
@@ -70,7 +70,7 @@ simcall_comm_irecv(simgrid::kernel::actor::ActorImpl* receiver, simgrid::kernel:
   xbt_assert(mbox, "No rendez-vous point defined for irecv");
 
   simgrid::kernel::actor::CommIrecvSimcall observer(receiver, mbox, static_cast<unsigned char*>(dst_buff),
-                                                    dst_buff_size, match_fun, copy_data_fun, data, rate);
+                                                    dst_buff_size, match_fun, copy_data_fun, data, rate, "Irecv");
   return simgrid::kernel::actor::simcall_answered(
       [&observer] { return simgrid::kernel::activity::CommImpl::irecv(&observer); });
 }
@@ -82,7 +82,7 @@ ssize_t simcall_comm_waitany(simgrid::kernel::activity::CommImpl* comms[], size_
   for (size_t i = 0; i < count; i++)
     activities.push_back(static_cast<simgrid::kernel::activity::ActivityImpl*>(comms[i]));
   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
-  simgrid::kernel::actor::ActivityWaitanySimcall observer{issuer, activities, timeout};
+  simgrid::kernel::actor::ActivityWaitanySimcall observer{issuer, activities, timeout, "Waitany"};
   ssize_t changed_pos = simgrid::kernel::actor::simcall_blocking(
       [&observer] {
         simgrid::kernel::activity::ActivityImpl::wait_any_for(observer.get_issuer(), observer.get_activities(),
@@ -103,7 +103,7 @@ ssize_t simcall_comm_testany(simgrid::kernel::activity::CommImpl* comms[], size_
     activities.push_back(static_cast<simgrid::kernel::activity::ActivityImpl*>(comms[i]));
 
   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
-  simgrid::kernel::actor::ActivityTestanySimcall observer{issuer, activities};
+  simgrid::kernel::actor::ActivityTestanySimcall observer{issuer, activities, "Testany"};
   ssize_t changed_pos = simgrid::kernel::actor::simcall_blocking(
       [&observer] {
         simgrid::kernel::activity::ActivityImpl::test_any(observer.get_issuer(), observer.get_activities());
@@ -124,7 +124,7 @@ void simcall_comm_wait(simgrid::kernel::activity::ActivityImpl* comm, double tim
 bool simcall_comm_test(simgrid::kernel::activity::ActivityImpl* comm) // XBT_ATTRIB_DEPRECATED_v335
 {
   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
-  simgrid::kernel::actor::ActivityTestSimcall observer{issuer, comm};
+  simgrid::kernel::actor::ActivityTestSimcall observer{issuer, comm, "Test"};
   if (simgrid::kernel::actor::simcall_blocking([&observer] { observer.get_activity()->test(observer.get_issuer()); },
                                                &observer)) {
     comm->get_iface()->complete(simgrid::s4u::Activity::State::FINISHED);

diff --git a/src/kernel/actor/CommObserver.hpp b/src/kernel/actor/CommObserver.hpp
index 0fbd797..c00a62e 100644 (file)
--- a/src/kernel/actor/CommObserver.hpp
+++ b/src/kernel/actor/CommObserver.hpp
@@ -20,7 +20,7 @@ class ActivityTestSimcall final : public ResultingSimcall<bool> {
   std::string fun_call_;
 
 public:
-  ActivityTestSimcall(ActorImpl* actor, activity::ActivityImpl* activity, std::string fun_call = "")
+  ActivityTestSimcall(ActorImpl* actor, activity::ActivityImpl* activity, std::string fun_call)
       : ResultingSimcall(actor, true), activity_(activity), fun_call_(fun_call)
   {
   }
@@ -37,7 +37,7 @@ class ActivityTestanySimcall final : public ResultingSimcall<ssize_t> {
 
 public:
   ActivityTestanySimcall(ActorImpl* actor, const std::vector<activity::ActivityImpl*>& activities,
-                         std::string fun_call = "none");
+                         std::string fun_call);
   bool is_enabled() override { return true; /* can return -1 if no activity is ready */ }
   void serialize(std::stringstream& stream) const override;
   std::string to_string() const override;
@@ -53,7 +53,7 @@ class ActivityWaitSimcall final : public ResultingSimcall<bool> {
   std::string fun_call_;
 
 public:
-  ActivityWaitSimcall(ActorImpl* actor, activity::ActivityImpl* activity, double timeout, std::string fun_call = "none")
+  ActivityWaitSimcall(ActorImpl* actor, activity::ActivityImpl* activity, double timeout, std::string fun_call)
       : ResultingSimcall(actor, false), activity_(activity), timeout_(timeout), fun_call_(fun_call)
   {
   }
@@ -74,7 +74,7 @@ class ActivityWaitanySimcall final : public ResultingSimcall<ssize_t> {
 
 public:
   ActivityWaitanySimcall(ActorImpl* actor, const std::vector<activity::ActivityImpl*>& activities, double timeout,
-                         std::string fun_call = "none");
+                         std::string fun_call);
   bool is_enabled() override;
   void serialize(std::stringstream& stream) const override;
   std::string to_string() const override;
@@ -109,7 +109,7 @@ public:
       const std::function<void(void*)>& clean_fun, // used to free the synchro in case of problem after a detached send
       const std::function<void(activity::CommImpl*, void*, size_t)>&
           copy_data_fun, // used to copy data if not default one
-      void* payload, bool detached, std::string fun_call = "none")
+      void* payload, bool detached, std::string fun_call)
       : SimcallObserver(actor)
       , mbox_(mbox)
       , payload_size_(payload_size)
@@ -159,7 +159,7 @@ public:
   CommIrecvSimcall(ActorImpl* actor, activity::MailboxImpl* mbox, unsigned char* dst_buff, size_t* dst_buff_size,
                    const std::function<bool(void*, void*, activity::CommImpl*)>& match_fun,
                    const std::function<void(activity::CommImpl*, void*, size_t)>& copy_data_fun, void* payload,
-                   double rate, std::string fun_call = "none")
+                   double rate, std::string fun_call)
       : SimcallObserver(actor)
       , mbox_(mbox)
       , dst_buff_(dst_buff)

diff --git a/src/s4u/s4u_Activity.cpp b/src/s4u/s4u_Activity.cpp
index aa352f1..65fd067 100644 (file)
--- a/src/s4u/s4u_Activity.cpp
+++ b/src/s4u/s4u_Activity.cpp
@@ -60,7 +60,7 @@ Activity* Activity::wait_for(double timeout)
   }
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  kernel::actor::ActivityWaitSimcall observer{issuer, pimpl_.get(), timeout};
+  kernel::actor::ActivityWaitSimcall observer{issuer, pimpl_.get(), timeout, "wait_for"};
   if (kernel::actor::simcall_blocking(
           [&observer] { observer.get_activity()->wait_for(observer.get_issuer(), observer.get_timeout()); }, &observer))
     throw TimeoutException(XBT_THROW_POINT, "Timeouted");
@@ -80,7 +80,7 @@ bool Activity::test()
     this->start();
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  kernel::actor::ActivityTestSimcall observer{issuer, pimpl_.get()};
+  kernel::actor::ActivityTestSimcall observer{issuer, pimpl_.get(), "test"};
   if (kernel::actor::simcall_answered([&observer] { return observer.get_activity()->test(observer.get_issuer()); },
                                       &observer)) {
     complete(State::FINISHED);
@@ -96,7 +96,7 @@ ssize_t Activity::test_any(const std::vector<ActivityPtr>& activities)
                  [](const ActivityPtr& act) { return act->pimpl_.get(); });
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  kernel::actor::ActivityTestanySimcall observer{issuer, ractivities};
+  kernel::actor::ActivityTestanySimcall observer{issuer, ractivities, "test_any"};
   ssize_t changed_pos = kernel::actor::simcall_answered(
       [&observer] {
         return kernel::activity::ActivityImpl::test_any(observer.get_issuer(), observer.get_activities());
@@ -114,7 +114,7 @@ ssize_t Activity::wait_any_for(const std::vector<ActivityPtr>& activities, doubl
                  [](const ActivityPtr& activity) { return activity->pimpl_.get(); });
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  kernel::actor::ActivityWaitanySimcall observer{issuer, ractivities, timeout};
+  kernel::actor::ActivityWaitanySimcall observer{issuer, ractivities, timeout, "wait_any_for"};
   ssize_t changed_pos = kernel::actor::simcall_blocking(
       [&observer] {
         kernel::activity::ActivityImpl::wait_any_for(observer.get_issuer(), observer.get_activities(),

diff --git a/src/s4u/s4u_Comm.cpp b/src/s4u/s4u_Comm.cpp
index ac97c56..d9a6101 100644 (file)
--- a/src/s4u/s4u_Comm.cpp
+++ b/src/s4u/s4u_Comm.cpp
@@ -78,12 +78,13 @@ void Comm::send(kernel::actor::ActorImpl* sender, const Mailbox* mbox, double ta
     simgrid::kernel::activity::ActivityImplPtr comm = nullptr;
 
     simgrid::kernel::actor::CommIsendSimcall send_observer{
-        sender,  mbox->get_impl(), task_size, rate, static_cast<unsigned char*>(src_buff), src_buff_size, match_fun,
-        nullptr, copy_data_fun,    data,      false};
+        sender,        mbox->get_impl(), task_size, rate,          static_cast<unsigned char*>(src_buff),
+        src_buff_size, match_fun,        nullptr,   copy_data_fun, data,
+        false,         "Isend"};
     comm = simgrid::kernel::actor::simcall_answered(
         [&send_observer] { return simgrid::kernel::activity::CommImpl::isend(&send_observer); }, &send_observer);
 
-    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{sender, comm.get(), timeout};
+    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{sender, comm.get(), timeout, "Wait"};
         simgrid::kernel::actor::simcall_blocking(
             [&wait_observer] {
               wait_observer.get_activity()->wait_for(wait_observer.get_issuer(), wait_observer.get_timeout());
@@ -95,7 +96,7 @@ void Comm::send(kernel::actor::ActorImpl* sender, const Mailbox* mbox, double ta
   } else {
     simgrid::kernel::actor::CommIsendSimcall observer(sender, mbox->get_impl(), task_size, rate,
                                                       static_cast<unsigned char*>(src_buff), src_buff_size, match_fun,
-                                                      nullptr, copy_data_fun, data, false);
+                                                      nullptr, copy_data_fun, data, false, "Isend");
     simgrid::kernel::actor::simcall_blocking([&observer, timeout] {
       simgrid::kernel::activity::ActivityImplPtr comm = simgrid::kernel::activity::CommImpl::isend(&observer);
       comm->wait_for(observer.get_issuer(), timeout);
@@ -122,11 +123,12 @@ void Comm::recv(kernel::actor::ActorImpl* receiver, const Mailbox* mbox, void* d
                                                       match_fun,
                                                       copy_data_fun,
                                                       data,
-                                                      rate};
+                                                      rate,
+                                                      "Irecv"};
     comm = simgrid::kernel::actor::simcall_answered(
         [&observer] { return simgrid::kernel::activity::CommImpl::irecv(&observer); }, &observer);
 
-    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{receiver, comm.get(), timeout};
+    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{receiver, comm.get(), timeout, "wait"};
         simgrid::kernel::actor::simcall_blocking(
             [&wait_observer] {
               wait_observer.get_activity()->wait_for(wait_observer.get_issuer(), wait_observer.get_timeout());
@@ -137,7 +139,7 @@ void Comm::recv(kernel::actor::ActorImpl* receiver, const Mailbox* mbox, void* d
     comm = nullptr;
   } else {
     simgrid::kernel::actor::CommIrecvSimcall observer(receiver, mbox->get_impl(), static_cast<unsigned char*>(dst_buff),
-                                                      dst_buff_size, match_fun, copy_data_fun, data, rate);
+                                                      dst_buff_size, match_fun, copy_data_fun, data, rate, "Irecv");
     simgrid::kernel::actor::simcall_blocking([&observer, timeout] {
       simgrid::kernel::activity::ActivityImplPtr comm = simgrid::kernel::activity::CommImpl::irecv(&observer);
       comm->wait_for(observer.get_issuer(), timeout);
@@ -331,7 +333,8 @@ Comm* Comm::do_start()
                                              clean_fun_,
                                              copy_data_function_,
                                              get_data<void>(),
-                                             detached_};
+                                             detached_,
+                                             "Isend"};
     pimpl_ = kernel::actor::simcall_answered([&observer] { return kernel::activity::CommImpl::isend(&observer); },
                                              &observer);
   } else if (dst_buff_ != nullptr) { // Receiver side
@@ -345,7 +348,8 @@ Comm* Comm::do_start()
                                              match_fun_,
                                              copy_data_function_,
                                              get_data<void>(),
-                                             rate_};
+                                             rate_,
+                                             "Irecv"};
     pimpl_ = kernel::actor::simcall_answered([&observer] { return kernel::activity::CommImpl::irecv(&observer); },
                                              &observer);
   } else {
@@ -422,7 +426,7 @@ Comm* Comm::wait_for(double timeout)
     case State::STARTED:
       try {
         issuer = kernel::actor::ActorImpl::self();
-        kernel::actor::ActivityWaitSimcall observer{issuer, pimpl_.get(), timeout};
+        kernel::actor::ActivityWaitSimcall observer{issuer, pimpl_.get(), timeout, "Wait"};
         if (kernel::actor::simcall_blocking(
                 [&observer] { observer.get_activity()->wait_for(observer.get_issuer(), observer.get_timeout()); },
                 &observer)) {