-#include "../simix/smx_private.h"
-#include "mc_snapshot.h"
-
-SG_BEGIN_DECL()
-
-extern mc_global_t initial_global_state;
-
-/* 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;
-
-/* An exploration state.
- *
- * The `executed_state` is sometimes transformed into another `internal_req`.
- * For example WAITANY is transformes into a WAIT and TESTANY into TEST.
- * See `MC_state_set_executed_request()`.
+#include "src/simix/smx_private.h"
+#include "src/kernel/activity/SynchroIo.hpp"
+#include "src/kernel/activity/SynchroComm.hpp"
+#include "src/kernel/activity/SynchroRaw.hpp"
+#include "src/kernel/activity/SynchroSleep.hpp"
+#include "src/kernel/activity/SynchroExec.hpp"
+#include "src/mc/mc_snapshot.h"
+#include "src/mc/mc_record.h"
+#include "src/mc/Transition.hpp"
+
+namespace simgrid {
+namespace mc {
+
+enum class PatternCommunicationType {
+ none = 0,
+ send = 1,
+ receive = 2,
+};
+
+struct PatternCommunication {
+ int num = 0;
+ smx_activity_t comm_addr;
+ PatternCommunicationType type = PatternCommunicationType::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;
+ }
+
+};
+
+/* On every state, each process has an entry of the following type.
+ * This represents both the process and its transition because
+ * a process cannot have more than one enabled transition at a given time.
+ */
+class ProcessState {
+ /* Possible exploration status of a process transition in a state.
+ * Either the checker did not consider the transition, or it was considered and to do, or considered and done.
+ */
+ enum class InterleavingType {
+ /** This process transition is not considered by the checker (yet?) */
+ disabled = 0,
+ /** The checker algorithm decided that this process transitions should be done at some point */
+ todo,
+ /** The checker algorithm decided that this should be done, but it was done in the meanwhile */
+ done,
+ };
+
+ /** Exploration control information */
+ InterleavingType state = InterleavingType::disabled;
+public:
+ /** Number of times that the process was considered to be executed */
+ // TODO, make this private
+ unsigned int times_considered = 0;
+
+ bool isDisabled() const {
+ return this->state == InterleavingType::disabled;
+ }
+ bool isDone() const {
+ return this->state == InterleavingType::done;
+ }
+ bool isTodo() const {
+ return this->state == InterleavingType::todo;
+ }
+ /** Mark that we should try executing this process at some point in the future of the checker algorithm */
+ void consider() {
+ this->state = InterleavingType::todo;
+ this->times_considered = 0;
+ }
+ void setDone() {
+ this->state = InterleavingType::done;
+ }
+};
+
+/* A node in the exploration graph (kind-of)