fix out of source builds

[simgrid.git] / src / mc / checker / CommunicationDeterminismChecker.cpp

diff --git a/src/mc/checker/CommunicationDeterminismChecker.cpp b/src/mc/checker/CommunicationDeterminismChecker.cpp
index f9e5fb1..f67819b 100644 (file)
--- a/src/mc/checker/CommunicationDeterminismChecker.cpp
+++ b/src/mc/checker/CommunicationDeterminismChecker.cpp
@@ -167,16 +167,15 @@ void CommunicationDeterminismChecker::deterministic_comm_pattern(int process, si
 
 /********** Non Static functions ***********/
 
-void CommunicationDeterminismChecker::get_comm_pattern(xbt_dynar_t list, smx_simcall_t request,
-                                                       e_mc_call_type_t call_type, int backtracking)
+void CommunicationDeterminismChecker::get_comm_pattern(smx_simcall_t request, e_mc_call_type_t call_type,
+                                                       int backtracking)
 {
   const smx_actor_t issuer = MC_smx_simcall_get_issuer(request);
   simgrid::mc::PatternCommunicationList* initial_pattern =
       xbt_dynar_get_as(initial_communications_pattern, issuer->get_pid(), simgrid::mc::PatternCommunicationList*);
   xbt_dynar_t incomplete_pattern = xbt_dynar_get_as(incomplete_communications_pattern, issuer->get_pid(), xbt_dynar_t);
 
-  std::unique_ptr<simgrid::mc::PatternCommunication> pattern =
-      std::unique_ptr<simgrid::mc::PatternCommunication>(new simgrid::mc::PatternCommunication());
+  std::unique_ptr<simgrid::mc::PatternCommunication> pattern(new simgrid::mc::PatternCommunication());
   pattern->index = initial_pattern->index_comm + xbt_dynar_length(incomplete_pattern);
 
   if (call_type == MC_CALL_TYPE_SEND) {
@@ -257,8 +256,7 @@ void CommunicationDeterminismChecker::get_comm_pattern(xbt_dynar_t list, smx_sim
 }
 
 void CommunicationDeterminismChecker::complete_comm_pattern(
-    xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr, unsigned int issuer,
-    int backtracking)
+    simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr, unsigned int issuer, int backtracking)
 {
   simgrid::mc::PatternCommunication* current_comm_pattern;
   unsigned int cursor = 0;
@@ -272,7 +270,7 @@ void CommunicationDeterminismChecker::complete_comm_pattern(
       completed = 1;
       simgrid::mc::PatternCommunication* temp;
       xbt_dynar_remove_at(xbt_dynar_get_as(incomplete_communications_pattern, issuer, xbt_dynar_t), cursor, &temp);
-      comm_pattern = std::unique_ptr<simgrid::mc::PatternCommunication>(temp);
+      comm_pattern.reset(temp);
       XBT_DEBUG("Remove incomplete comm pattern for process %u at cursor %u", issuer, cursor);
       break;
     }
@@ -293,7 +291,7 @@ void CommunicationDeterminismChecker::complete_comm_pattern(
   }
 }
 
-CommunicationDeterminismChecker::CommunicationDeterminismChecker(Session& session) : Checker(session)
+CommunicationDeterminismChecker::CommunicationDeterminismChecker(Session& s) : Checker(s)
 {
 }
 
@@ -386,10 +384,10 @@ static inline bool all_communications_are_finished()
 void CommunicationDeterminismChecker::restoreState()
 {
   /* Intermediate backtracking */
-  simgrid::mc::State* state = stack_.back().get();
-  if (state->system_state) {
-    simgrid::mc::restore_snapshot(state->system_state);
-    MC_restore_communications_pattern(state);
+  simgrid::mc::State* last_state = stack_.back().get();
+  if (last_state->system_state) {
+    simgrid::mc::restore_snapshot(last_state->system_state);
+    MC_restore_communications_pattern(last_state);
     return;
   }
 
@@ -422,7 +420,7 @@ void CommunicationDeterminismChecker::restoreState()
     /* TODO : handle test and testany simcalls */
     e_mc_call_type_t call = MC_get_call_type(req);
     mc_model_checker->handle_simcall(state->transition);
-    MC_handle_comm_pattern(call, req, req_num, nullptr, 1);
+    MC_handle_comm_pattern(call, req, req_num, 1);
     mc_model_checker->wait_for_requests();
 
     /* Update statistics */
@@ -438,23 +436,23 @@ void CommunicationDeterminismChecker::real_run()
 
   while (not stack_.empty()) {
     /* Get current state */
-    simgrid::mc::State* state = stack_.back().get();
+    simgrid::mc::State* cur_state = stack_.back().get();
 
     XBT_DEBUG("**************************************************");
-    XBT_DEBUG("Exploration depth = %zu (state = %d, interleaved processes = %zu)", stack_.size(), state->num,
-              state->interleaveSize());
+    XBT_DEBUG("Exploration depth = %zu (state = %d, interleaved processes = %zu)", stack_.size(), cur_state->num,
+              cur_state->interleaveSize());
 
     /* Update statistics */
     mc_model_checker->visited_states++;
 
     if (stack_.size() <= (std::size_t)_sg_mc_max_depth)
-      req = MC_state_get_request(state);
+      req = MC_state_get_request(cur_state);
     else
       req = nullptr;
 
     if (req != nullptr && visited_state == nullptr) {
 
-      int req_num = state->transition.argument;
+      int req_num = cur_state->transition.argument;
 
       XBT_DEBUG("Execute: %s", simgrid::mc::request_to_string(req, req_num, simgrid::mc::RequestType::simix).c_str());
 
@@ -470,13 +468,10 @@ void CommunicationDeterminismChecker::real_run()
         call = MC_get_call_type(req);
 
       /* Answer the request */
-      mc_model_checker->handle_simcall(state->transition);
+      mc_model_checker->handle_simcall(cur_state->transition);
       /* After this call req is no longer useful */
 
-      if (not this->initial_communications_pattern_done)
-        MC_handle_comm_pattern(call, req, req_num, initial_communications_pattern, 0);
-      else
-        MC_handle_comm_pattern(call, req, req_num, nullptr, 0);
+      MC_handle_comm_pattern(call, req, req_num, 0);
 
       /* Wait for requests (schedules processes) */
       mc_model_checker->wait_for_requests();
@@ -503,11 +498,10 @@ void CommunicationDeterminismChecker::real_run()
             next_state->addInterleavingSet(actor.copy.getBuffer());
 
         if (dot_output != nullptr)
-          fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n",
-            state->num,  next_state->num, req_str.c_str());
+          fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", cur_state->num, next_state->num, req_str.c_str());
 
       } else if (dot_output != nullptr)
-        fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", state->num,
+        fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", cur_state->num,
                 visited_state->original_num == -1 ? visited_state->num : visited_state->original_num, req_str.c_str());
 
       stack_.push_back(std::move(next_state));
@@ -526,7 +520,7 @@ void CommunicationDeterminismChecker::real_run()
         this->initial_communications_pattern_done = 1;
 
       /* Trash the current state, no longer needed */
-      XBT_DEBUG("Delete state %d at depth %zu", state->num, stack_.size());
+      XBT_DEBUG("Delete state %d at depth %zu", cur_state->num, stack_.size());
       stack_.pop_back();
 
       visited_state = nullptr;
@@ -570,9 +564,9 @@ void CommunicationDeterminismChecker::run()
   this->real_run();
 }
 
-Checker* createCommunicationDeterminismChecker(Session& session)
+Checker* createCommunicationDeterminismChecker(Session& s)
 {
-  return new CommunicationDeterminismChecker(session);
+  return new CommunicationDeterminismChecker(s);
 }
 
 }