X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1d95145df4657e19b9a02db53de4c9f758a0c6f5..2bdd4ab1f667695dbf8aeedfe7d3d940991146cd:/src/mc/mc_state.h diff --git a/src/mc/mc_state.h b/src/mc/mc_state.h index 40c9a6eb33..fa5ddb98d7 100644 --- a/src/mc/mc_state.h +++ b/src/mc/mc_state.h @@ -7,6 +7,9 @@ #ifndef SIMGRID_MC_STATE_H #define SIMGRID_MC_STATE_H +#include +#include + #include #include @@ -14,58 +17,155 @@ #include "src/simix/smx_private.h" #include "src/mc/mc_snapshot.h" -SG_BEGIN_DECL() +namespace simgrid { +namespace mc { + +extern XBT_PRIVATE std::unique_ptr 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 data; + int tag = 0; + int index = 0; -extern XBT_PRIVATE mc_global_t initial_global_state; + PatternCommunication() + { + std::memset(&comm_addr, 0, sizeof(comm_addr)); + } -/* 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; + 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 */ -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; +class ProcessState { + /* Possible exploration status of a process in a state */ + enum class InterleavingType { + /** We do not have to execute this process transitions */ + disabled = 0, + /** We still have to execute (some of) this process transitions */ + interleave, + /** We have already executed this process transitions */ + done, + }; + + /** Exploration control information */ + InterleavingType state = InterleavingType::disabled; +public: + + /** Number of times that the process was interleaved */ + // TODO, make this private + unsigned int interleave_count = 0; + + bool isDisabled() const + { + return this->state == InterleavingType::disabled; + } + bool isDone() const + { + return this->state == InterleavingType::done; + } + bool isToInterleave() const + { + return this->state == InterleavingType::interleave; + } + void interleave() + { + this->state = InterleavingType::interleave; + this->interleave_count = 0; + } + void setDone() + { + this->state = InterleavingType::done; + } +}; /* 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()`. + * See `MC_state_get_request_for_process()`. */ -typedef struct XBT_PRIVATE mc_state { - unsigned long max_pid; /* Maximum pid at state's creation time */ - mc_procstate_t proc_status; /* State's exploration status by process */ - 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; /* The request number (in the case of a - multi-request like waitany ) */ - mc_snapshot_t system_state; /* Snapshot of system state */ - int num; - int in_visited_states; - // comm determinism verification (xbt_dynar_t): - xbt_dynar_t incomplete_comm_pattern; - xbt_dynar_t index_comm; // comm determinism verification -} s_mc_state_t, *mc_state_t; - -XBT_PRIVATE mc_state_t MC_state_new(void); -XBT_PRIVATE void MC_state_delete(mc_state_t state, int free_snapshot); -XBT_PRIVATE void MC_state_interleave_process(mc_state_t state, smx_process_t process); -XBT_PRIVATE unsigned int MC_state_interleave_size(mc_state_t state); -XBT_PRIVATE int MC_state_process_is_done(mc_state_t state, smx_process_t process); -XBT_PRIVATE void MC_state_set_executed_request(mc_state_t state, smx_simcall_t req, int value); -XBT_PRIVATE smx_simcall_t MC_state_get_executed_request(mc_state_t state, int *value); -XBT_PRIVATE smx_simcall_t MC_state_get_internal_request(mc_state_t state); -XBT_PRIVATE smx_simcall_t MC_state_get_request(mc_state_t state, int *value); -XBT_PRIVATE void MC_state_remove_interleave_process(mc_state_t state, smx_process_t process); - -SG_END_DECL() +struct XBT_PRIVATE State { + + /** Sequential state number (used for debugging) */ + int num = 0; + + /* Next transition to explore for this communication + * + * Some transitions are not deterministic such as: + * + * * waitany which can receive different messages; + * + * * random which can produce different values. + * + * This variable is used to keep track of which transition + * should be explored next for a given simcall. + */ + int req_num = 0; + + /** State's exploration status by process */ + std::vector processStates; + + /** The simcall */ + s_smx_simcall_t executed_req; + + /* Internal translation of the simcall + * + * IMCALL_COMM_TESTANY is translated to a SIMCALL_COMM_TEST + * and SIMCALL_COMM_WAITANY to a SIMCALL_COMM_WAIT. + */ + s_smx_simcall_t internal_req; + + /* Can be used as a copy of the remote synchro object */ + s_smx_synchro_t internal_comm; + + /** Snapshot of system state (if needed) */ + std::shared_ptr system_state; + + // For CommunicationDeterminismChecker + std::vector> incomplete_comm_pattern; + std::vector communicationIndices; + + State(); + + std::size_t interleaveSize() const; + void interleave(smx_process_t process) + { + this->processStates[process->pid].interleave(); + } +}; + +XBT_PRIVATE void replay(std::list> const& stack); + +} +} + +XBT_PRIVATE simgrid::mc::State* MC_state_new(void); +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); #endif