[mc] Use std::vector for State::incomplete_comm_pattern (dexbtification)

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

diff --git a/src/mc/CommunicationDeterminismChecker.cpp b/src/mc/CommunicationDeterminismChecker.cpp
index da1b86e..ef800b9 100644 (file)
--- a/src/mc/CommunicationDeterminismChecker.cpp
+++ b/src/mc/CommunicationDeterminismChecker.cpp
@@ -35,7 +35,7 @@ xbt_dynar_t incomplete_communications_pattern;
 
 /********** Static functions ***********/
 
-static e_mc_comm_pattern_difference_t compare_comm_pattern(mc_comm_pattern_t comm1, mc_comm_pattern_t comm2) {
+static e_mc_comm_pattern_difference_t compare_comm_pattern(simgrid::mc::PatternCommunication* comm1, simgrid::mc::PatternCommunication* comm2) {
   if(comm1->type != comm2->type)
     return TYPE_DIFF;
   if (comm1->rdv != comm2->rdv)
@@ -53,7 +53,7 @@ static e_mc_comm_pattern_difference_t compare_comm_pattern(mc_comm_pattern_t com
   return NONE_DIFF;
 }
 
-static char* print_determinism_result(e_mc_comm_pattern_difference_t diff, int process, mc_comm_pattern_t comm, unsigned int cursor) {
+static char* print_determinism_result(e_mc_comm_pattern_difference_t diff, int process, simgrid::mc::PatternCommunication* comm, unsigned int cursor) {
   char *type, *res;
 
   if(comm->type == SIMIX_COMM_SEND)
@@ -91,7 +91,7 @@ static char* print_determinism_result(e_mc_comm_pattern_difference_t diff, int p
   return res;
 }
 
-static void update_comm_pattern(mc_comm_pattern_t comm_pattern, smx_synchro_t comm_addr)
+static void update_comm_pattern(simgrid::mc::PatternCommunication* comm_pattern, smx_synchro_t comm_addr)
 {
   s_smx_synchro_t comm;
   mc_model_checker->process().read(&comm, remote(comm_addr));
@@ -113,14 +113,14 @@ static void update_comm_pattern(mc_comm_pattern_t comm_pattern, smx_synchro_t co
   }
 }
 
-static void deterministic_comm_pattern(int process, mc_comm_pattern_t comm, int backtracking) {
+static void deterministic_comm_pattern(int process, simgrid::mc::PatternCommunication* comm, int backtracking) {
 
-  mc_list_comm_pattern_t list =
-    xbt_dynar_get_as(initial_communications_pattern, process, mc_list_comm_pattern_t);
+  simgrid::mc::PatternCommunicationList* list =
+    xbt_dynar_get_as(initial_communications_pattern, process, simgrid::mc::PatternCommunicationList*);
 
   if(!backtracking){
-    mc_comm_pattern_t initial_comm =
-      xbt_dynar_get_as(list->list, list->index_comm, mc_comm_pattern_t);
+    simgrid::mc::PatternCommunication* initial_comm =
+      xbt_dynar_get_as(list->list, list->index_comm, simgrid::mc::PatternCommunication*);
     e_mc_comm_pattern_difference_t diff =
       compare_comm_pattern(initial_comm, comm);
 
@@ -163,7 +163,7 @@ static void deterministic_comm_pattern(int process, mc_comm_pattern_t comm, int
     }
   }
 
-  MC_comm_pattern_free(comm);
+  delete comm;
 
 }
 
@@ -172,12 +172,12 @@ static void deterministic_comm_pattern(int process, mc_comm_pattern_t comm, int
 void MC_get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type_t call_type, int backtracking)
 {
   const smx_process_t issuer = MC_smx_simcall_get_issuer(request);
-  mc_list_comm_pattern_t initial_pattern = xbt_dynar_get_as(
-    initial_communications_pattern, issuer->pid, mc_list_comm_pattern_t);
+  simgrid::mc::PatternCommunicationList* initial_pattern = xbt_dynar_get_as(
+    initial_communications_pattern, issuer->pid, simgrid::mc::PatternCommunicationList*);
   xbt_dynar_t incomplete_pattern = xbt_dynar_get_as(
     incomplete_communications_pattern, issuer->pid, xbt_dynar_t);
 
-  mc_comm_pattern_t pattern = new s_mc_comm_pattern_t();
+  simgrid::mc::PatternCommunication* pattern = new simgrid::mc::PatternCommunication();
   pattern->index =
     initial_pattern->index_comm + xbt_dynar_length(incomplete_pattern);
 
@@ -211,14 +211,14 @@ void MC_get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type
         /* Store comm pattern */
         xbt_dynar_push(
           xbt_dynar_get_as(
-            initial_communications_pattern, pattern->src_proc, mc_list_comm_pattern_t
+            initial_communications_pattern, pattern->src_proc, simgrid::mc::PatternCommunicationList*
           )->list,
           &pattern);
       } else {
         /* Evaluate comm determinism */
         deterministic_comm_pattern(pattern->src_proc, pattern, backtracking);
         xbt_dynar_get_as(
-          initial_communications_pattern, pattern->src_proc, mc_list_comm_pattern_t
+          initial_communications_pattern, pattern->src_proc, simgrid::mc::PatternCommunicationList*
         )->index_comm++;
       }
       return;
@@ -252,9 +252,9 @@ void MC_get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type
 }
 
 void MC_complete_comm_pattern(xbt_dynar_t list, smx_synchro_t comm_addr, unsigned int issuer, int backtracking) {
-  mc_comm_pattern_t current_comm_pattern;
+  simgrid::mc::PatternCommunication* current_comm_pattern;
   unsigned int cursor = 0;
-  mc_comm_pattern_t comm_pattern;
+  simgrid::mc::PatternCommunication* comm_pattern;
   int completed = 0;
 
   /* Complete comm pattern */
@@ -272,8 +272,8 @@ void MC_complete_comm_pattern(xbt_dynar_t list, smx_synchro_t comm_addr, unsigne
   if(!completed)
     xbt_die("Corresponding communication not found!");
 
-  mc_list_comm_pattern_t pattern = xbt_dynar_get_as(
-    initial_communications_pattern, issuer, mc_list_comm_pattern_t);
+  simgrid::mc::PatternCommunicationList* pattern = xbt_dynar_get_as(
+    initial_communications_pattern, issuer, simgrid::mc::PatternCommunicationList*);
 
   if (!simgrid::mc::initial_global_state->initial_communications_pattern_done)
     /* Store comm pattern */
@@ -337,10 +337,10 @@ void CommunicationDeterminismChecker::prepare()
   const int maxpid = MC_smx_get_maxpid();
 
   // Create initial_communications_pattern elements:
-  initial_communications_pattern = xbt_dynar_new(sizeof(mc_list_comm_pattern_t), MC_list_comm_pattern_free_voidp);
+  initial_communications_pattern = simgrid::xbt::newDeleteDynar<simgrid::mc::PatternCommunicationList*>();
   for (i=0; i < maxpid; i++){
-    mc_list_comm_pattern_t process_list_pattern = xbt_new0(s_mc_list_comm_pattern_t, 1);
-    process_list_pattern->list = xbt_dynar_new(sizeof(mc_comm_pattern_t), MC_comm_pattern_free_voidp);
+    simgrid::mc::PatternCommunicationList* process_list_pattern = new simgrid::mc::PatternCommunicationList();
+    process_list_pattern->list = simgrid::xbt::newDeleteDynar<simgrid::mc::PatternCommunication>();
     process_list_pattern->index_comm = 0;
     xbt_dynar_insert_at(initial_communications_pattern, i, &process_list_pattern);
   }
@@ -348,7 +348,7 @@ void CommunicationDeterminismChecker::prepare()
   // Create incomplete_communications_pattern elements:
   incomplete_communications_pattern = xbt_dynar_new(sizeof(xbt_dynar_t), xbt_dynar_free_voidp);
   for (i=0; i < maxpid; i++){
-    xbt_dynar_t process_pattern = xbt_dynar_new(sizeof(mc_comm_pattern_t), nullptr);
+    xbt_dynar_t process_pattern = xbt_dynar_new(sizeof(simgrid::mc::PatternCommunication*), nullptr);
     xbt_dynar_insert_at(incomplete_communications_pattern, i, &process_pattern);
   }
 
@@ -520,10 +520,6 @@ int CommunicationDeterminismChecker::run()
   XBT_INFO("Check communication determinism");
   mc_model_checker->wait_for_requests();
 
-  if (mc_mode == MC_MODE_CLIENT)
-    // This will move somehwere else:
-    simgrid::mc::Client::get()->handleMessages();
-
   this->prepare();
 
   initial_global_state = std::unique_ptr<s_mc_global_t>(new s_mc_global_t());