-/* Copyright (c) 2008-2021. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2008-2022. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
namespace mc {
void CommunicationDeterminismChecker::deterministic_comm_pattern(aid_t process, const PatternCommunication* comm,
- int backtracking)
+ bool backtracking)
{
if (not backtracking) {
PatternCommunicationList& list = initial_communications_pattern[process];
/********** Non Static functions ***********/
-void CommunicationDeterminismChecker::get_comm_pattern(smx_simcall_t request, CallType call_type, int backtracking)
+void CommunicationDeterminismChecker::get_comm_pattern(smx_simcall_t request, CallType call_type, bool backtracking)
{
const smx_actor_t issuer = api::get().simcall_get_issuer(request);
const mc::PatternCommunicationList& initial_pattern = initial_communications_pattern[issuer->get_pid()];
incomplete_communications_pattern[issuer->get_pid()].push_back(pattern.release());
}
-void CommunicationDeterminismChecker::complete_comm_pattern(RemotePtr<kernel::activity::CommImpl> const& comm_addr, aid_t issuer,
- int backtracking)
+void CommunicationDeterminismChecker::complete_comm_pattern(RemotePtr<kernel::activity::CommImpl> const& comm_addr,
+ aid_t issuer, bool backtracking)
{
/* Complete comm pattern */
std::vector<PatternCommunication*>& incomplete_pattern = incomplete_communications_pattern[issuer];
auto current_comm_pattern =
std::find_if(begin(incomplete_pattern), end(incomplete_pattern),
[&comm_addr](const PatternCommunication* comm) { return (comm->comm_addr == comm_addr); });
- if (current_comm_pattern == std::end(incomplete_pattern))
- xbt_die("Corresponding communication not found!");
+ xbt_assert(current_comm_pattern != std::end(incomplete_pattern), "Corresponding communication not found!");
update_comm_pattern(*current_comm_pattern, comm_addr);
std::unique_ptr<PatternCommunication> comm_pattern(*current_comm_pattern);
std::vector<std::string> CommunicationDeterminismChecker::get_textual_trace() // override
{
std::vector<std::string> trace;
- for (auto const& state : stack_) {
- smx_simcall_t req = &state->executed_req_;
- trace.push_back(api::get().request_to_string(req, state->transition_.times_considered_));
- }
+ for (auto const& state : stack_)
+ trace.push_back(api::get().request_to_string(state->transition_.aid_, state->transition_.times_considered_));
return trace;
}
/* Add all enabled actors to the interleave set of the initial state */
for (auto& act : api::get().get_actors()) {
auto actor = act.copy.get_buffer();
- if (api::get().actor_is_enabled(actor->get_pid()))
- initial_state->mark_todo(actor);
+ if (get_session().actor_is_enabled(actor->get_pid()))
+ initial_state->mark_todo(actor->get_pid());
}
stack_.push_back(std::move(initial_state));
return;
}
- session->restore_initial_state();
+ get_session().restore_initial_state();
const unsigned long maxpid = api::get().get_maxpid();
assert(maxpid == incomplete_communications_pattern.size());
}
}
-void CommunicationDeterminismChecker::handle_comm_pattern(simgrid::mc::CallType call_type, smx_simcall_t req, int value, int backtracking)
+void CommunicationDeterminismChecker::handle_comm_pattern(simgrid::mc::CallType call_type, smx_simcall_t req, int value,
+ bool backtracking)
{
using simgrid::mc::CallType;
switch(call_type) {
void CommunicationDeterminismChecker::real_run()
{
std::unique_ptr<VisitedState> visited_state = nullptr;
- smx_simcall_t req = nullptr;
while (not stack_.empty()) {
/* Get current state */
/* Update statistics */
api::get().mc_inc_visited_states();
+ bool found_transition = false;
if (stack_.size() <= (std::size_t)_sg_mc_max_depth)
- req = api::get().mc_state_choose_request(cur_state);
- else
- req = nullptr;
+ found_transition = api::get().mc_state_choose_request(cur_state);
- if (req != nullptr && visited_state == nullptr) {
+ if (found_transition && visited_state == nullptr) {
+ aid_t aid = cur_state->transition_.aid_;
int req_num = cur_state->transition_.times_considered_;
+ smx_simcall_t req = &cur_state->executed_req_;
- XBT_DEBUG("Execute: %s", api::get().request_to_string(req, req_num).c_str());
+ XBT_DEBUG("Execute: %s", api::get().request_to_string(aid, req_num).c_str());
std::string req_str;
if (dot_output != nullptr)
- req_str = api::get().request_get_dot_output(req, req_num);
+ req_str = api::get().request_get_dot_output(aid, req_num);
api::get().mc_inc_executed_trans();
/* Add all enabled actors to the interleave set of the next state */
for (auto& act : api::get().get_actors()) {
auto actor = act.copy.get_buffer();
- if (api::get().actor_is_enabled(actor->get_pid()))
- next_state->mark_todo(actor);
+ if (get_session().actor_is_enabled(actor->get_pid()))
+ next_state->mark_todo(actor->get_pid());
}
if (dot_output != nullptr)
void CommunicationDeterminismChecker::run()
{
XBT_INFO("Check communication determinism");
- get_session()->take_initial_snapshot();
+ get_session().take_initial_snapshot();
this->prepare();
this->real_run();
}
-Checker* createCommunicationDeterminismChecker(Session* session)
+Checker* create_communication_determinism_checker(Session* session)
{
return new CommunicationDeterminismChecker(session);
}
