X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a15797ea55151ddfdbae48147e74159efe01b411..9692d43fa911bdc2d6d0263a3cb3e22d5e3167fe:/src/mc/mc_state.cpp

diff --git a/src/mc/mc_state.cpp b/src/mc/mc_state.cpp
index 4f467f266f..5033b70e23 100644
--- a/src/mc/mc_state.cpp
+++ b/src/mc/mc_state.cpp
@@ -6,7 +6,7 @@
 
 #include <assert.h>
 
-#include <algorithm>
+#include <boost/range/algorithm.hpp>
 
 #include <xbt/log.h>
 #include <xbt/sysdep.h>
@@ -56,8 +56,8 @@ State::State()
 
 std::size_t State::interleaveSize() const
 {
-  return std::count_if(this->processStates.begin(), this->processStates.end(),
-    [](simgrid::mc::ProcessState const& state) { return state.isToInterleave(); });
+  return boost::range::count_if(this->processStates,
+    [](simgrid::mc::ProcessState const& p) { return p.isToInterleave(); });
 }
 
 Transition State::getTransition() const
@@ -69,7 +69,7 @@ Transition State::getTransition() const
 }
 
 static inline smx_simcall_t MC_state_get_request_for_process(
-  simgrid::mc::State* state, smx_process_t process)
+  simgrid::mc::State* state, smx_actor_t process)
 {
   simgrid::mc::ProcessState* procstate = &state->processStates[process->pid];
   state->transition.pid = -1;
@@ -106,8 +106,7 @@ static inline smx_simcall_t MC_state_get_request_for_process(
         unsigned start_count = procstate->interleave_count;
         state->transition.argument = -1;
         while (procstate->interleave_count <
-                read_length(mc_model_checker->process(),
-                  remote(simcall_comm_testany__get__comms(&process->simcall))))
+                simcall_comm_testany__get__count(&process->simcall))
           if (simgrid::mc::request_is_enabled_by_idx(&process->simcall,
               procstate->interleave_count++)) {
             state->transition.argument = procstate->interleave_count - 1;
@@ -115,8 +114,7 @@ static inline smx_simcall_t MC_state_get_request_for_process(
           }
 
         if (procstate->interleave_count >=
-            read_length(mc_model_checker->process(),
-              remote(simcall_comm_testany__get__comms(&process->simcall))))
+            simcall_comm_testany__get__count(&process->simcall))
           procstate->setDone();
 
         if (state->transition.argument != -1 || start_count == 0)
@@ -126,11 +124,11 @@ static inline smx_simcall_t MC_state_get_request_for_process(
       }
 
       case SIMCALL_COMM_WAIT: {
-        simgrid::mc::RemotePtr<simgrid::simix::Comm> remote_act = remote(
-          static_cast<simgrid::simix::Comm*>(simcall_comm_wait__get__comm(&process->simcall)));
-        simgrid::mc::Remote<simgrid::simix::Comm> temp_act;
+        simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> remote_act = remote(
+          static_cast<simgrid::kernel::activity::Comm*>(simcall_comm_wait__get__comm(&process->simcall)));
+        simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_act;
         mc_model_checker->process().read(temp_act, remote_act);
-        simgrid::simix::Comm* act = temp_act.getBuffer();
+        simgrid::kernel::activity::Comm* act = temp_act.getBuffer();
         if (act->src_proc && act->dst_proc)
           state->transition.argument = 0;
         else if (act->src_proc == nullptr && act->type == SIMIX_COMM_READY
@@ -175,12 +173,12 @@ static inline smx_simcall_t MC_state_get_request_for_process(
   case SIMCALL_COMM_WAITANY: {
     state->internal_req.call = SIMCALL_COMM_WAIT;
     state->internal_req.issuer = req->issuer;
-    smx_synchro_t remote_comm;
+    smx_activity_t remote_comm;
     read_element(mc_model_checker->process(),
       &remote_comm, remote(simcall_comm_waitany__get__comms(req)),
       state->transition.argument, sizeof(remote_comm));
     mc_model_checker->process().read(state->internal_comm, remote(
-      static_cast<simgrid::simix::Comm*>(remote_comm)));
+      static_cast<simgrid::kernel::activity::Comm*>(remote_comm)));
     simcall_comm_wait__set__comm(&state->internal_req, state->internal_comm.getBuffer());
     simcall_comm_wait__set__timeout(&state->internal_req, 0);
     break;
@@ -191,12 +189,10 @@ static inline smx_simcall_t MC_state_get_request_for_process(
     state->internal_req.issuer = req->issuer;
 
     if (state->transition.argument > 0) {
-      smx_synchro_t remote_comm;
-      read_element(mc_model_checker->process(),
-        &remote_comm, remote(simcall_comm_testany__get__comms(req)),
-        state->transition.argument, sizeof(remote_comm));
+      smx_activity_t remote_comm = mc_model_checker->process().read(
+        remote(simcall_comm_testany__get__comms(req) + state->transition.argument));
       mc_model_checker->process().read(state->internal_comm, remote(
-        static_cast<simgrid::simix::Comm*>(remote_comm)));
+        static_cast<simgrid::kernel::activity::Comm*>(remote_comm)));
     }
 
     simcall_comm_test__set__comm(&state->internal_req, state->internal_comm.getBuffer());