RecordTrace SafetyChecker::getRecordTrace() // override
{
RecordTrace res;
- for (auto const& state : stack_) {
- int value = 0;
- smx_simcall_t saved_req = MC_state_get_executed_request(state.get(), &value);
- const smx_process_t issuer = MC_smx_simcall_get_issuer(saved_req);
- const int pid = issuer->pid;
- res.push_back(RecordTraceElement(pid, value));
- }
+ for (auto const& state : stack_)
+ res.push_back(state->getRecordElement());
return res;
}
{
std::vector<std::string> trace;
for (auto const& state : stack_) {
- int value;
- smx_simcall_t req = MC_state_get_executed_request(state.get(), &value);
+ int value = state->req_num;
+ smx_simcall_t req = &state->executed_req;
if (req)
trace.push_back(simgrid::mc::request_to_string(
req, value, simgrid::mc::RequestType::executed));
{
this->init();
- int value;
-
while (!stack_.empty()) {
/* Get current state */
// let's back-track.
smx_simcall_t req = nullptr;
if (stack_.size() > (std::size_t) _sg_mc_max_depth
- || (req = MC_state_get_request(state, &value)) == nullptr
+ || (req = MC_state_get_request(state)) == nullptr
|| visitedState_ != nullptr) {
int res = this->backtrack();
if (res)
continue;
}
+ int req_num = state->req_num;
+
// If there are processes to interleave and the maximum depth has not been
// reached then perform one step of the exploration algorithm.
XBT_DEBUG("Execute: %s",
simgrid::mc::request_to_string(
- req, value, simgrid::mc::RequestType::simix).c_str());
+ req, req_num, simgrid::mc::RequestType::simix).c_str());
std::string req_str;
if (dot_output != nullptr)
- req_str = simgrid::mc::request_get_dot_output(req, value);
+ req_str = simgrid::mc::request_get_dot_output(req, req_num);
- MC_state_set_executed_request(state, req, value);
mc_stats->executed_transitions++;
// TODO, bundle both operations in a single message
- // MC_execute_transition(req, value)
+ // MC_execute_transition(req, req_num)
/* Answer the request */
- simgrid::mc::handle_simcall(req, value);
+ simgrid::mc::handle_simcall(req, req_num);
mc_model_checker->wait_for_requests();
/* Create the new expanded state */
/* Get an enabled process and insert it in the interleave set of the next state */
for (auto& p : mc_model_checker->process().simix_processes())
if (simgrid::mc::process_is_enabled(&p.copy)) {
- MC_state_interleave_process(next_state.get(), &p.copy);
+ next_state->interleave(&p.copy);
if (reductionMode_ != simgrid::mc::ReductionMode::none)
break;
}
std::unique_ptr<simgrid::mc::State> state = std::move(stack_.back());
stack_.pop_back();
if (reductionMode_ == simgrid::mc::ReductionMode::dpor) {
- smx_simcall_t req = MC_state_get_internal_request(state.get());
+ smx_simcall_t req = &state->internal_req;
if (req->call == SIMCALL_MUTEX_LOCK || req->call == SIMCALL_MUTEX_TRYLOCK)
xbt_die("Mutex is currently not supported with DPOR, "
"use --cfg=model-check/reduction:none");
for (auto i = stack_.rbegin(); i != stack_.rend(); ++i) {
simgrid::mc::State* prev_state = i->get();
if (reductionMode_ != simgrid::mc::ReductionMode::none
- && simgrid::mc::request_depend(req, MC_state_get_internal_request(prev_state))) {
+ && simgrid::mc::request_depend(req, &prev_state->internal_req)) {
if (XBT_LOG_ISENABLED(mc_safety, xbt_log_priority_debug)) {
XBT_DEBUG("Dependent Transitions:");
- int value;
- smx_simcall_t prev_req = MC_state_get_executed_request(prev_state, &value);
+ int value = prev_state->req_num;
+ smx_simcall_t prev_req = &prev_state->executed_req;
XBT_DEBUG("%s (state=%d)",
simgrid::mc::request_to_string(
prev_req, value, simgrid::mc::RequestType::internal).c_str(),
prev_state->num);
- prev_req = MC_state_get_executed_request(state.get(), &value);
+ value = state->req_num;
+ prev_req = &state->executed_req;
XBT_DEBUG("%s (state=%d)",
simgrid::mc::request_to_string(
prev_req, value, simgrid::mc::RequestType::executed).c_str(),
state->num);
}
- if (!prev_state->processStates[issuer->pid].done())
- MC_state_interleave_process(prev_state, issuer);
+ if (!prev_state->processStates[issuer->pid].isDone())
+ prev_state->interleave(issuer);
else
XBT_DEBUG("Process %p is in done set", req->issuer);
break;
- } else if (req->issuer == MC_state_get_internal_request(prev_state)->issuer) {
+ } else if (req->issuer == prev_state->internal_req.issuer) {
- XBT_DEBUG("Simcall %d and %d with same issuer", req->call, MC_state_get_internal_request(prev_state)->call);
+ XBT_DEBUG("Simcall %d and %d with same issuer", req->call, prev_state->internal_req.call);
break;
} else {
- const smx_process_t previous_issuer = MC_smx_simcall_get_issuer(MC_state_get_internal_request(prev_state));
+ const smx_process_t previous_issuer = MC_smx_simcall_get_issuer(&prev_state->internal_req);
XBT_DEBUG("Simcall %d, process %lu (state %d) and simcall %d, process %lu (state %d) are independant",
req->call, issuer->pid, state->num,
- MC_state_get_internal_request(prev_state)->call,
+ prev_state->internal_req.call,
previous_issuer->pid,
prev_state->num);
/* Get an enabled process and insert it in the interleave set of the initial state */
for (auto& p : mc_model_checker->process().simix_processes())
if (simgrid::mc::process_is_enabled(&p.copy)) {
- MC_state_interleave_process(initial_state.get(), &p.copy);
+ initial_state->interleave(&p.copy);
if (reductionMode_ != simgrid::mc::ReductionMode::none)
break;
}