X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c5309c7efaf73d81f7aa8cb7908348d0db5677fe..98d2f4bc9ec0e7394f0c0e54f378353081193efe:/src/mc/mc_state.h

diff --git a/src/mc/mc_state.h b/src/mc/mc_state.h
index 68acc459e6..3fb62da892 100644
--- a/src/mc/mc_state.h
+++ b/src/mc/mc_state.h
@@ -17,26 +17,73 @@
 #include "src/simix/smx_private.h"
 #include "src/mc/mc_snapshot.h"
 
-/* Possible exploration status of a process in a state */
-typedef enum {
-  MC_NOT_INTERLEAVE=0,      /* Do not interleave (do not execute) */
-  MC_INTERLEAVE,            /* Interleave the process (one or more request) */
-  MC_MORE_INTERLEAVE,       /* Interleave twice the process (for mc_random simcall) */
-  MC_DONE                   /* Already interleaved */
-} e_mc_process_state_t;
-
-/* On every state, each process has an entry of the following type */
-typedef struct mc_procstate{
-  e_mc_process_state_t state;       /* Exploration control information */
-  unsigned int interleave_count;    /* Number of times that the process was
-                                       interleaved */
-} s_mc_procstate_t, *mc_procstate_t;
-
 namespace simgrid {
 namespace mc {
 
 extern XBT_PRIVATE std::unique_ptr<s_mc_global_t> initial_global_state;
 
+struct PatternCommunication {
+  int num = 0;
+  smx_synchro_t comm_addr;
+  e_smx_comm_type_t type = SIMIX_COMM_SEND;
+  unsigned long src_proc = 0;
+  unsigned long dst_proc = 0;
+  const char *src_host = nullptr;
+  const char *dst_host = nullptr;
+  std::string rdv;
+  std::vector<char> data;
+  int tag = 0;
+  int index = 0;
+
+  PatternCommunication()
+  {
+    std::memset(&comm_addr, 0, sizeof(comm_addr));
+  }
+
+  PatternCommunication dup() const
+  {
+    simgrid::mc::PatternCommunication res;
+    // num?
+    res.comm_addr = this->comm_addr;
+    res.type = this->type;
+    // src_proc?
+    // dst_proc?
+    res.dst_proc = this->dst_proc;
+    res.dst_host = this->dst_host;
+    res.rdv = this->rdv;
+    res.data = this->data;
+    // tag?
+    res.index = this->index;
+    return res;
+  }
+
+};
+
+/* Possible exploration status of a process in a state */
+enum class ProcessInterleaveState {
+  no_interleave=0, /* Do not interleave (do not execute) */
+  interleave,      /* Interleave the process (one or more request) */
+  more_interleave, /* Interleave twice the process (for mc_random simcall) */
+  done             /* Already interleaved */
+};
+
+/* On every state, each process has an entry of the following type */
+struct ProcessState {
+  /** Exploration control information */
+  ProcessInterleaveState state = ProcessInterleaveState::no_interleave;
+  /** Number of times that the process was interleaved */
+  unsigned int interleave_count;
+
+  bool done() const
+  {
+    return this->state == ProcessInterleaveState::done;
+  }
+  bool interleave() const {
+    return this->state == ProcessInterleaveState::interleave
+      || this->state == ProcessInterleaveState::more_interleave;
+  }
+};
+
 /* An exploration state.
  *
  *  The `executed_state` is sometimes transformed into another `internal_req`.
@@ -44,9 +91,9 @@ extern XBT_PRIVATE std::unique_ptr<s_mc_global_t> initial_global_state;
  *  See `MC_state_set_executed_request()`.
  */
 struct XBT_PRIVATE State {
-  unsigned long max_pid = 0;            /* Maximum pid at state's creation time */
-  mc_procstate_t proc_status = 0;       /* State's exploration status by process */
-  s_smx_synchro_t internal_comm;     /* To be referenced by the internal_req */
+  /** State's exploration status by process */
+  std::vector<ProcessState> processStates;
+  s_smx_synchro_t internal_comm;        /* To be referenced by the internal_req */
   s_smx_simcall_t internal_req;         /* Internal translation of request */
   s_smx_simcall_t executed_req;         /* The executed request of the state */
   int req_num = 0;                      /* The request number (in the case of a
@@ -54,28 +101,28 @@ struct XBT_PRIVATE State {
   std::shared_ptr<simgrid::mc::Snapshot> system_state = nullptr;      /* Snapshot of system state */
   int num = 0;
   int in_visited_states = 0;
-  // comm determinism verification (xbt_dynar_t<xbt_dynar_t<mc_comm_pattern_t>):
-  xbt_dynar_t incomplete_comm_pattern = nullptr;
-  xbt_dynar_t index_comm = nullptr; // comm determinism verification
+
+  // comm determinism verification (xbt_dynar_t<xbt_dynar_t<simgrid::mc::PatternCommunication*>):
+  std::vector<std::vector<simgrid::mc::PatternCommunication>> incomplete_comm_pattern;
+
+  // For communication determinism verification:
+  std::vector<unsigned> communicationIndices;
 
   State();
-  ~State();
+
+  std::size_t interleaveSize() const;
 };
 
-XBT_PRIVATE void replay(std::list<simgrid::mc::State*> const& stack);
+XBT_PRIVATE void replay(std::list<std::unique_ptr<simgrid::mc::State>> const& stack);
 
 }
 }
 
 XBT_PRIVATE simgrid::mc::State* MC_state_new(void);
-XBT_PRIVATE void MC_state_delete(simgrid::mc::State* state, int free_snapshot);
 XBT_PRIVATE void MC_state_interleave_process(simgrid::mc::State* state, smx_process_t process);
-XBT_PRIVATE unsigned int MC_state_interleave_size(simgrid::mc::State* state);
-XBT_PRIVATE int MC_state_process_is_done(simgrid::mc::State* state, smx_process_t process);
 XBT_PRIVATE void MC_state_set_executed_request(simgrid::mc::State* state, smx_simcall_t req, int value);
 XBT_PRIVATE smx_simcall_t MC_state_get_executed_request(simgrid::mc::State* state, int *value);
 XBT_PRIVATE smx_simcall_t MC_state_get_internal_request(simgrid::mc::State* state);
 XBT_PRIVATE smx_simcall_t MC_state_get_request(simgrid::mc::State* state, int *value);
-XBT_PRIVATE void MC_state_remove_interleave_process(simgrid::mc::State* state, smx_process_t process);
 
 #endif