#include <cstring>
-#include <algorithm>
#include <memory>
#include <list>
+#include <boost/range/algorithm.hpp>
+
#include <unistd.h>
#include <sys/wait.h>
}
}
-Pair::Pair() : num(++mc_stats->expanded_pairs)
+Pair::Pair(unsigned long expanded_pairs) : num(expanded_pairs)
{}
Pair::~Pair() {}
pair->num, pair->automaton_state, pair->atomic_propositions,
pair->graph_state);
- auto res = std::equal_range(acceptancePairs_.begin(), acceptancePairs_.end(),
+ auto res = boost::range::equal_range(acceptancePairs_,
new_pair.get(), simgrid::mc::DerefAndCompareByNbProcessesAndUsedHeap());
if (pair->search_cycle) for (auto i = res.first; i != res.second; ++i) {
explorationStack_.pop_back();
if (dot_output != nullptr)
fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n",
- initial_global_state->prev_pair, pair_test->num,
- initial_global_state->prev_req.c_str());
+ this->previousPair_, pair_test->num,
+ this->previousRequest_.c_str());
return nullptr;
}
void LivenessChecker::prepare(void)
{
- initial_global_state->snapshot = simgrid::mc::take_snapshot(0);
- initial_global_state->prev_pair = 0;
+ this->previousPair_ = 0;
std::shared_ptr<const std::vector<int>> propos = this->getPropositionValues();
}
/* Restore the initial state */
- simgrid::mc::restore_snapshot(initial_global_state->snapshot);
+ simgrid::mc::session->restoreInitialState();
/* Traverse the stack from the initial state and re-execute the transitions */
int depth = 1;
if (saved_req != nullptr) {
/* because we got a copy of the executed request, we have to fetch the
real one, pointed by the request field of the issuer process */
- const smx_process_t issuer = MC_smx_simcall_get_issuer(saved_req);
+ const smx_actor_t issuer = MC_smx_simcall_get_issuer(saved_req);
req = &issuer->simcall;
/* Debug information */
}
/* Update statistics */
- mc_stats->visited_pairs++;
- mc_stats->executed_transitions++;
+ visitedPairsCount_++;
+ mc_model_checker->executed_transitions++;
depth++;
pair->num, pair->automaton_state, pair->atomic_propositions,
pair->graph_state);
- auto range = std::equal_range(visitedPairs_.begin(), visitedPairs_.end(),
+ auto range = boost::range::equal_range(visitedPairs_,
visited_pair.get(), simgrid::mc::DerefAndCompareByNbProcessesAndUsedHeap());
for (auto i = range.first; i != range.second; ++i) {
{
if (_sg_mc_visited != 0 && visitedPairs_.size() > (std::size_t) _sg_mc_visited) {
// Remove the oldest entry with a linear search:
- visitedPairs_.erase(std::min_element(
- visitedPairs_.begin(), visitedPairs_.end(),
+ visitedPairs_.erase(boost::min_element(visitedPairs_,
[](std::shared_ptr<VisitedPair> const a, std::shared_ptr<VisitedPair> const& b) {
return a->num < b->num; } ));
}
void LivenessChecker::logState() // override
{
Checker::logState();
- XBT_INFO("Expanded pairs = %lu", mc_stats->expanded_pairs);
- XBT_INFO("Visited pairs = %lu", mc_stats->visited_pairs);
- XBT_INFO("Executed transitions = %lu", mc_stats->executed_transitions);
+ XBT_INFO("Expanded pairs = %lu", expandedPairsCount_);
+ XBT_INFO("Visited pairs = %lu", visitedPairsCount_);
+ XBT_INFO("Executed transitions = %lu", mc_model_checker->executed_transitions);
}
void LivenessChecker::showAcceptanceCycle(std::size_t depth)
reached_pair, current_pair.get())) != -1) {
if (dot_output != nullptr){
fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n",
- initial_global_state->prev_pair, visited_num,
- initial_global_state->prev_req.c_str());
+ this->previousPair_, visited_num,
+ this->previousRequest_.c_str());
fflush(dot_output);
}
XBT_DEBUG("Pair already visited (equal to pair %d), exploration on the current path stopped.", visited_num);
int req_num = current_pair->graph_state->transition.argument;
if (dot_output != nullptr) {
- if (initial_global_state->prev_pair != 0 && initial_global_state->prev_pair != current_pair->num) {
+ if (this->previousPair_ != 0 && this->previousPair_ != current_pair->num) {
fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n",
- initial_global_state->prev_pair, current_pair->num,
- initial_global_state->prev_req.c_str());
- initial_global_state->prev_req.clear();
+ this->previousPair_, current_pair->num,
+ this->previousRequest_.c_str());
+ this->previousRequest_.clear();
}
- initial_global_state->prev_pair = current_pair->num;
- initial_global_state->prev_req = simgrid::mc::request_get_dot_output(req, req_num);
+ this->previousPair_ = current_pair->num;
+ this->previousRequest_ = simgrid::mc::request_get_dot_output(req, req_num);
if (current_pair->search_cycle)
fprintf(dot_output, "%d [shape=doublecircle];\n", current_pair->num);
fflush(dot_output);
simgrid::mc::request_to_string(
req, req_num, simgrid::mc::RequestType::simix).c_str());
- /* Update mc_stats */
- mc_stats->executed_transitions++;
+ /* Update stats */
+ mc_model_checker->executed_transitions++;
if (!current_pair->exploration_started)
- mc_stats->visited_pairs++;
+ visitedPairsCount_++;
/* Answer the request */
mc_model_checker->handle_simcall(current_pair->graph_state->transition);
std::shared_ptr<Pair> LivenessChecker::newPair(Pair* current_pair, xbt_automaton_state_t state, std::shared_ptr<const std::vector<int>> propositions)
{
- std::shared_ptr<Pair> next_pair = std::make_shared<Pair>();
+ std::shared_ptr<Pair> next_pair = std::make_shared<Pair>(++expandedPairsCount_);
next_pair->automaton_state = state;
- next_pair->graph_state = std::shared_ptr<simgrid::mc::State>(MC_state_new());
+ next_pair->graph_state = std::shared_ptr<simgrid::mc::State>(MC_state_new(++expandedStatesCount_));
next_pair->atomic_propositions = std::move(propositions);
if (current_pair)
next_pair->depth = current_pair->depth + 1;
next_pair->depth = 1;
/* Get enabled processes and insert them in the interleave set of the next graph_state */
for (auto& p : mc_model_checker->process().simix_processes())
- if (simgrid::mc::process_is_enabled(&p.copy))
- next_pair->graph_state->interleave(&p.copy);
+ if (simgrid::mc::process_is_enabled(p.copy.getBuffer()))
+ next_pair->graph_state->interleave(p.copy.getBuffer());
next_pair->requests = next_pair->graph_state->interleaveSize();
/* FIXME : get search_cycle value for each acceptant state */
if (next_pair->automaton_state->type == 1 ||
next_pair->search_cycle = true;
else
next_pair->search_cycle = false;
- return std::move(next_pair);
+ return next_pair;
}
void LivenessChecker::backtrack()
{
XBT_INFO("Check the liveness property %s", _sg_mc_property_file);
MC_automaton_load(_sg_mc_property_file);
- mc_model_checker->wait_for_requests();
XBT_DEBUG("Starting the liveness algorithm");
-
- /* Create the initial state */
- simgrid::mc::initial_global_state = std::unique_ptr<s_mc_global_t>(new s_mc_global_t());
-
+ simgrid::mc::session->initialize();
this->prepare();
+
int res = this->main();
- simgrid::mc::initial_global_state = nullptr;
return res;
}