X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/33883442375c73f8116eca3ca3269a6f1725a285..d89ca681772fdaafdd69049d4d66676a4e98de38:/src/mc/api.cpp

diff --git a/src/mc/api.cpp b/src/mc/api.cpp
index b469ab0da3..f3e5b16171 100644
--- a/src/mc/api.cpp
+++ b/src/mc/api.cpp
@@ -52,8 +52,6 @@ static std::string buff_size_to_string(size_t buff_size)
   return XBT_LOG_ISENABLED(Api, xbt_log_priority_verbose) ? std::to_string(buff_size) : "(verbose only)";
 }
 
-static void simcall_translate(smx_simcall_t req, Remote<kernel::activity::CommImpl>& buffered_comm);
-
 /* Search an enabled transition for the given process.
  *
  * This can be seen as an iterator returning the next transition of the process.
@@ -127,75 +125,12 @@ simgrid::mc::ActorInformation* Api::actor_info_cast(smx_actor_t actor) const
   return process_info;
 }
 
-bool Api::simcall_check_dependency(smx_simcall_t req1, smx_simcall_t req2) const
+bool Api::requests_are_dependent(RemotePtr<kernel::actor::SimcallObserver> obs1,
+                                 RemotePtr<kernel::actor::SimcallObserver> obs2) const
 {
-  const auto IRECV = Simcall::COMM_IRECV;
-  const auto ISEND = Simcall::COMM_ISEND;
-  const auto WAIT  = Simcall::COMM_WAIT;
-
-  if (req1->issuer_ == req2->issuer_) // Done in observer for TEST and WAIT
-    return false;
-
-  /* The independence theorem only consider 4 simcalls. All others are dependent with anything. */
-  if (req1->call_ != ISEND && req1->call_ != IRECV && req1->call_ != WAIT)
-    return true;
-  if (req2->call_ != ISEND && req2->call_ != IRECV && req2->call_ != WAIT)
-    return true;
-
-  /* Make sure that req1 and req2 are in alphabetic order */
-  if (req1->call_ > req2->call_) {
-    auto temp = req1;
-    req1      = req2;
-    req2      = temp;
-  }
-
-  auto comm2 = get_comm_or_nullptr(req2);
-
-  /* First case: that's not the same kind of request (we also know that req1 < req2 alphabetically) */
-  if (req1->call_ != req2->call_) {
-    if (req1->call_ == IRECV && req2->call_ == ISEND)
-      return false;
-
-    if ((req1->call_ == IRECV || req1->call_ == ISEND) && req2->call_ == WAIT) {
-      auto mbox1 = get_mbox_remote_addr(req1);
-      auto mbox2 = remote(comm2->mbox_cpy);
-
-      if (mbox1 != mbox2 && simcall_comm_wait__get__timeout(req2) <= 0)
-        return false;
-
-      if ((req1->issuer_ != comm2->src_actor_.get()) && (req1->issuer_ != comm2->dst_actor_.get()) &&
-          simcall_comm_wait__get__timeout(req2) <= 0)
-        return false;
-
-      if ((req1->call_ == ISEND) && (comm2->type_ == kernel::activity::CommImpl::Type::SEND) &&
-          (comm2->src_buff_ != simcall_comm_isend__get__src_buff(req1)) && simcall_comm_wait__get__timeout(req2) <= 0)
-        return false;
-
-      if ((req1->call_ == IRECV) && (comm2->type_ == kernel::activity::CommImpl::Type::RECEIVE) &&
-          (comm2->dst_buff_ != simcall_comm_irecv__get__dst_buff(req1)) && simcall_comm_wait__get__timeout(req2) <= 0)
-        return false;
-    }
-
-    /* FIXME: the following rule assumes that the result of the isend/irecv call is not stored in a buffer used in the
-     * test call. */
-#if 0
-  if((req1->call == ISEND || req1->call == IRECV)
-      &&  req2->call == TEST)
-    return false;
-#endif
-
-    return true;
-  }
+  xbt_assert(mc_model_checker != nullptr, "Must be called from MCer");
 
-  /* Second case: req1 and req2 are of the same call type */
-  switch (req1->call_) {
-    case ISEND:
-      return simcall_comm_isend__get__mbox(req1) == simcall_comm_isend__get__mbox(req2);
-    case IRECV:
-      return simcall_comm_irecv__get__mbox(req1) == simcall_comm_irecv__get__mbox(req2);
-    default:
-      return true;
-  }
+  return mc_model_checker->requests_are_dependent(obs1, obs2);
 }
 
 xbt::string const& Api::get_actor_host_name(smx_actor_t actor) const
@@ -510,14 +445,18 @@ void Api::dump_record_path() const
 smx_simcall_t Api::mc_state_choose_request(simgrid::mc::State* state) const
 {
   RemoteProcess& process = mc_model_checker->get_remote_process();
+  XBT_DEBUG("Search for an actor to run. %zu actors to consider", process.actors().size());
   for (auto& actor : process.actors()) {
     /* Only consider the actors that were marked as interleaving by the checker algorithm */
     if (not state->actor_states_[actor.copy.get_buffer()->get_pid()].is_todo())
       continue;
 
     smx_simcall_t res = MC_state_choose_request_for_process(process, state, actor.copy.get_buffer());
-    if (res)
+    if (res) {
+      XBT_DEBUG("Let's run actor %ld, going for transition %s", actor.copy.get_buffer()->get_pid(),
+                SIMIX_simcall_name(*res));
       return res;
+    }
   }
   return nullptr;
 }
@@ -620,11 +559,11 @@ void Api::s_close() const
   session_singleton->close();
 }
 
-void Api::execute(Transition& transition, smx_simcall_t simcall) const
+RemotePtr<simgrid::kernel::actor::SimcallObserver> Api::execute(Transition& transition, smx_simcall_t simcall) const
 {
   /* FIXME: once all simcalls have observers, kill the simcall parameter and use mc_model_checker->simcall_to_string() */
   transition.textual = request_to_string(simcall, transition.times_considered_);
-  session_singleton->execute(transition);
+  return session_singleton->execute(transition);
 }
 
 void Api::automaton_load(const char* file) const