[mc] Rename the communication pattern types

diff --git a/src/mc/CommunicationDeterminismChecker.cpp b/src/mc/CommunicationDeterminismChecker.cpp
index 1fec4ed..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);
 
@@ -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 = simgrid::xbt::newDeleteDynar<mc_list_comm_pattern_t>();
+  initial_communications_pattern = simgrid::xbt::newDeleteDynar<simgrid::mc::PatternCommunicationList*>();
   for (i=0; i < maxpid; i++){
-    mc_list_comm_pattern_t process_list_pattern = new s_mc_list_comm_pattern_t();
-    process_list_pattern->list = simgrid::xbt::newDeleteDynar<s_mc_comm_pattern_t>();
+    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);
   }
 

diff --git a/src/mc/mc_comm_pattern.cpp b/src/mc/mc_comm_pattern.cpp
index d775fcc..2a332d0 100644 (file)
--- a/src/mc/mc_comm_pattern.cpp
+++ b/src/mc/mc_comm_pattern.cpp
@@ -21,9 +21,9 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_comm_pattern, mc,
 
 extern "C" {
 
-mc_comm_pattern_t MC_comm_pattern_dup(mc_comm_pattern_t comm)
+simgrid::mc::PatternCommunication* MC_comm_pattern_dup(simgrid::mc::PatternCommunication* comm)
 {
-  mc_comm_pattern_t res = new s_mc_comm_pattern_t();
+  simgrid::mc::PatternCommunication* res = new simgrid::mc::PatternCommunication();
   res->index = comm->index;
   res->type = comm->type;
   res->comm_addr = comm->comm_addr;
@@ -36,12 +36,12 @@ mc_comm_pattern_t MC_comm_pattern_dup(mc_comm_pattern_t comm)
 
 xbt_dynar_t MC_comm_patterns_dup(xbt_dynar_t patterns)
 {
-  xbt_dynar_t res = simgrid::xbt::newDeleteDynar<s_mc_comm_pattern_t>();
+  xbt_dynar_t res = simgrid::xbt::newDeleteDynar<simgrid::mc::PatternCommunication>();
 
-  mc_comm_pattern_t comm;
+  simgrid::mc::PatternCommunication* comm;
   unsigned int cursor;
   xbt_dynar_foreach(patterns, cursor, comm) {
-    mc_comm_pattern_t copy_comm = MC_comm_pattern_dup(comm);
+    simgrid::mc::PatternCommunication* copy_comm = MC_comm_pattern_dup(comm);
     xbt_dynar_push(res, &copy_comm);
   }
 
@@ -53,16 +53,16 @@ static void MC_patterns_copy(xbt_dynar_t dest, xbt_dynar_t source)
   xbt_dynar_reset(dest);
 
   unsigned int cursor;
-  mc_comm_pattern_t comm;
+  simgrid::mc::PatternCommunication* comm;
   xbt_dynar_foreach(source, cursor, comm) {
-    mc_comm_pattern_t copy_comm = MC_comm_pattern_dup(comm);
+    simgrid::mc::PatternCommunication* copy_comm = MC_comm_pattern_dup(comm);
     xbt_dynar_push(dest, &copy_comm);
   }
 }
 
 void MC_restore_communications_pattern(simgrid::mc::State* state)
 {
-  mc_list_comm_pattern_t list_process_comm;
+  simgrid::mc::PatternCommunicationList* list_process_comm;
   unsigned int cursor;
 
   xbt_dynar_foreach(initial_communications_pattern, cursor, list_process_comm)
@@ -89,7 +89,7 @@ void MC_state_copy_incomplete_communications_pattern(simgrid::mc::State* state)
 void MC_state_copy_index_communications_pattern(simgrid::mc::State* state)
 {
   state->communicationIndices.clear();
-  mc_list_comm_pattern_t list_process_comm;
+  simgrid::mc::PatternCommunicationList* list_process_comm;
   unsigned int cursor;
   xbt_dynar_foreach(initial_communications_pattern, cursor, list_process_comm)
     state->communicationIndices.push_back(list_process_comm->index_comm);

diff --git a/src/mc/mc_comm_pattern.h b/src/mc/mc_comm_pattern.h
index 463f378..828d174 100644 (file)
--- a/src/mc/mc_comm_pattern.h
+++ b/src/mc/mc_comm_pattern.h
@@ -22,9 +22,10 @@
 
 #include "src/mc/mc_state.h"
 
-SG_BEGIN_DECL()
+namespace simgrid {
+namespace mc {
 
-typedef struct s_mc_comm_pattern{
+struct PatternCommunication {
   int num = 0;
   smx_synchro_t comm_addr;
   e_smx_comm_type_t type = SIMIX_COMM_SEND;
@@ -37,27 +38,32 @@ typedef struct s_mc_comm_pattern{
   int tag = 0;
   int index = 0;
 
-  s_mc_comm_pattern()
+  PatternCommunication()
   {
     std::memset(&comm_addr, 0, sizeof(comm_addr));
   }
 
   // No copy:
-  s_mc_comm_pattern(s_mc_comm_pattern const&) = delete;
-  s_mc_comm_pattern& operator=(s_mc_comm_pattern const&) = delete;
+  PatternCommunication(PatternCommunication const&) = delete;
+  PatternCommunication& operator=(PatternCommunication const&) = delete;
 
-} s_mc_comm_pattern_t, *mc_comm_pattern_t;
+};
 
-typedef struct s_mc_list_comm_pattern{
+struct PatternCommunicationList {
   unsigned int index_comm = 0;
   xbt_dynar_t list = nullptr;
 
-  s_mc_list_comm_pattern() {}
-  ~s_mc_list_comm_pattern()
+  PatternCommunicationList() {}
+  ~PatternCommunicationList()
   {
     xbt_dynar_free(&(this->list));
   }
-}s_mc_list_comm_pattern_t, *mc_list_comm_pattern_t;
+};
+
+}
+}
+
+SG_BEGIN_DECL()
 
 /**
  *  Type: `xbt_dynar_t<mc_list_comm_pattenr_t>`
@@ -65,7 +71,7 @@ typedef struct s_mc_list_comm_pattern{
 extern XBT_PRIVATE xbt_dynar_t initial_communications_pattern;
 
 /**
- *  Type: `xbt_dynar_t<xbt_dynar_t<mc_comm_pattern_t>>`
+ *  Type: `xbt_dynar_t<xbt_dynar_t<simgrid::mc::PatternCommunication*>>`
  */
 extern XBT_PRIVATE xbt_dynar_t incomplete_communications_pattern;
 
@@ -110,7 +116,7 @@ XBT_PRIVATE void MC_complete_comm_pattern(xbt_dynar_t list, smx_synchro_t comm_a
 
 XBT_PRIVATE void MC_restore_communications_pattern(simgrid::mc::State* state);
 
-XBT_PRIVATE mc_comm_pattern_t MC_comm_pattern_dup(mc_comm_pattern_t comm);
+XBT_PRIVATE simgrid::mc::PatternCommunication* MC_comm_pattern_dup(simgrid::mc::PatternCommunication* comm);
 XBT_PRIVATE xbt_dynar_t MC_comm_patterns_dup(xbt_dynar_t state);
 
 XBT_PRIVATE void MC_state_copy_incomplete_communications_pattern(simgrid::mc::State* state);

diff --git a/src/mc/mc_global.cpp b/src/mc/mc_global.cpp
index 2f9f7e2..38609f9 100644 (file)
--- a/src/mc/mc_global.cpp
+++ b/src/mc/mc_global.cpp
@@ -149,7 +149,7 @@ void replay(std::list<std::unique_ptr<simgrid::mc::State>> const& stack)
     assert(n == xbt_dynar_length(initial_communications_pattern));
     for (unsigned j=0; j < n ; j++) {
       xbt_dynar_reset((xbt_dynar_t)xbt_dynar_get_as(incomplete_communications_pattern, j, xbt_dynar_t));
-      xbt_dynar_get_as(initial_communications_pattern, j, mc_list_comm_pattern_t)->index_comm = 0;
+      xbt_dynar_get_as(initial_communications_pattern, j, simgrid::mc::PatternCommunicationList*)->index_comm = 0;
     }
   }
 

diff --git a/src/mc/mc_state.h b/src/mc/mc_state.h
index a744151..5534a57 100644 (file)
--- a/src/mc/mc_state.h
+++ b/src/mc/mc_state.h
@@ -65,7 +65,7 @@ struct XBT_PRIVATE State {
   int num = 0;
   int in_visited_states = 0;
 
-  // comm determinism verification (xbt_dynar_t<xbt_dynar_t<mc_comm_pattern_t>):
+  // comm determinism verification (xbt_dynar_t<xbt_dynar_t<simgrid::mc::PatternCommunication*>):
   xbt_dynar_t incomplete_comm_pattern = nullptr;
 
   // For communication determinism verification: