xbt_die("Support for client-side function proposition is not implemented.");
XBT_DEBUG("Received symbol: %s", message.name);
- if (_mc_property_automaton == nullptr)
- _mc_property_automaton = xbt_automaton_new();
+ if (simgrid::mc::property_automaton == nullptr)
+ simgrid::mc::property_automaton = xbt_automaton_new();
simgrid::mc::Process* process = &this->process();
simgrid::mc::RemotePtr<int> address
= simgrid::mc::remote((int*) message.data);
- simgrid::xbt::add_proposition(_mc_property_automaton,
+ simgrid::xbt::add_proposition(simgrid::mc::property_automaton,
message.name,
[process, address]() { return process->read(address); }
);
int num1, num2;
if (_sg_mc_liveness) { /* Liveness MC */
- s1 = ((mc_visited_pair_t) state1)->graph_state->system_state;
- s2 = ((mc_visited_pair_t) state2)->graph_state->system_state;
- num1 = ((mc_visited_pair_t) state1)->num;
- num2 = ((mc_visited_pair_t) state2)->num;
+ s1 = ((simgrid::mc::VisitedPair*) state1)->graph_state->system_state;
+ s2 = ((simgrid::mc::VisitedPair*) state2)->graph_state->system_state;
+ num1 = ((simgrid::mc::VisitedPair*) state1)->num;
+ num2 = ((simgrid::mc::VisitedPair*) state2)->num;
}else if (_sg_mc_termination) { /* Non-progressive cycle MC */
s1 = ((mc_state_t) state1)->system_state;
s2 = ((mc_state_t) state2)->system_state;
xbt_fifo_t mc_stack = nullptr;
/* Liveness */
-xbt_automaton_t _mc_property_automaton = nullptr;
+
+namespace simgrid {
+namespace mc {
+
+xbt_automaton_t property_automaton = nullptr;
+
+}
+}
/* Dot output */
FILE *dot_output = nullptr;
void MC_replay_liveness(xbt_fifo_t stack)
{
xbt_fifo_item_t item;
- mc_pair_t pair = nullptr;
+ simgrid::mc::Pair* pair = nullptr;
mc_state_t state = nullptr;
smx_simcall_t req = nullptr, saved_req = NULL;
int value, depth = 1;
/* Intermediate backtracking */
if(_sg_mc_checkpoint > 0) {
item = xbt_fifo_get_first_item(stack);
- pair = (mc_pair_t) xbt_fifo_get_item_content(item);
+ pair = (simgrid::mc::Pair*) xbt_fifo_get_item_content(item);
if(pair->graph_state->system_state){
simgrid::mc::restore_snapshot(pair->graph_state->system_state);
return;
item != xbt_fifo_get_first_item(stack);
item = xbt_fifo_get_prev_item(item)) {
- pair = (mc_pair_t) xbt_fifo_get_item_content(item);
+ pair = (simgrid::mc::Pair*) xbt_fifo_get_item_content(item);
state = (mc_state_t) pair->graph_state;
MC_print_statistics(mc_stats);
}
+namespace simgrid {
+namespace mc {
-void MC_show_stack_liveness(xbt_fifo_t stack)
+void show_stack_liveness(xbt_fifo_t stack)
{
int value;
- mc_pair_t pair;
+ simgrid::mc::Pair* pair;
xbt_fifo_item_t item;
smx_simcall_t req;
char *req_str = nullptr;
for (item = xbt_fifo_get_last_item(stack);
item; item = xbt_fifo_get_prev_item(item)) {
- pair = (mc_pair_t) xbt_fifo_get_item_content(item);
+ pair = (simgrid::mc::Pair*) xbt_fifo_get_item_content(item);
req = MC_state_get_executed_request(pair->graph_state, &value);
if (req && req->call != SIMCALL_NONE) {
req_str = simgrid::mc::request_to_string(req, value, simgrid::mc::RequestType::executed);
}
}
-
-void MC_dump_stack_liveness(xbt_fifo_t stack)
+void dump_stack_liveness(xbt_fifo_t stack)
{
- mc_pair_t pair;
- while ((pair = (mc_pair_t) xbt_fifo_pop(stack)) != nullptr)
- MC_pair_delete(pair);
+ simgrid::mc::Pair* pair;
+ while ((pair = (simgrid::mc::Pair*) xbt_fifo_pop(stack)) != nullptr)
+ simgrid::mc::pair_delete(pair);
+}
+
+}
}
void MC_print_statistics(mc_stats_t stats)
void MC_automaton_load(const char *file)
{
- if (_mc_property_automaton == nullptr)
- _mc_property_automaton = xbt_automaton_new();
+ if (simgrid::mc::property_automaton == nullptr)
+ simgrid::mc::property_automaton = xbt_automaton_new();
- xbt_automaton_load(_mc_property_automaton, file);
+ xbt_automaton_load(simgrid::mc::property_automaton, file);
}
// TODO, fix cross-process access (this function is not used)
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_liveness, mc,
"Logging specific to algorithms for liveness properties verification");
+}
+
/********* Global variables *********/
xbt_dynar_t acceptance_pairs;
unsigned int cursor = 0;
xbt_automaton_propositional_symbol_t ps = nullptr;
xbt_dynar_t values = xbt_dynar_new(sizeof(int), nullptr);
- xbt_dynar_foreach(_mc_property_automaton->propositional_symbols, cursor, ps) {
+ xbt_dynar_foreach(simgrid::mc::property_automaton->propositional_symbols, cursor, ps) {
int res = xbt_automaton_propositional_symbol_evaluate(ps);
xbt_dynar_push_as(values, int, res);
}
return values;
}
-static mc_visited_pair_t is_reached_acceptance_pair(mc_pair_t pair)
+static simgrid::mc::VisitedPair* is_reached_acceptance_pair(simgrid::mc::Pair* pair)
{
- mc_visited_pair_t new_pair = nullptr;
- new_pair = MC_visited_pair_new(pair->num, pair->automaton_state, pair->atomic_propositions, pair->graph_state);
+ simgrid::mc::VisitedPair* new_pair = nullptr;
+ new_pair = simgrid::mc::visited_pair_new(pair->num, pair->automaton_state, pair->atomic_propositions, pair->graph_state);
new_pair->acceptance_pair = 1;
if (xbt_dynar_is_empty(acceptance_pairs))
int min = -1, max = -1, index;
//int res;
- mc_visited_pair_t pair_test;
+ simgrid::mc::VisitedPair* pair_test;
int cursor;
index = get_search_interval(acceptance_pairs, new_pair, &min, &max);
// Parallell implementation
/*res = xbt_parmap_mc_apply(parmap, snapshot_compare, xbt_dynar_get_ptr(acceptance_pairs, min), (max-min)+1, pair);
if(res != -1){
- return ((mc_pair_t)xbt_dynar_get_as(acceptance_pairs, (min+res)-1, mc_pair_t))->num;
+ return ((simgrid::mc::Pair*)xbt_dynar_get_as(acceptance_pairs, (min+res)-1, simgrid::mc::Pair*))->num;
} */
cursor = min;
if(pair->search_cycle == 1){
while (cursor <= max) {
- pair_test = (mc_visited_pair_t) xbt_dynar_get_as(acceptance_pairs, cursor, mc_visited_pair_t);
+ pair_test = (simgrid::mc::VisitedPair*) xbt_dynar_get_as(acceptance_pairs, cursor, simgrid::mc::VisitedPair*);
if (xbt_automaton_state_compare(pair_test->automaton_state, new_pair->automaton_state) == 0) {
if (xbt_automaton_propositional_symbols_compare_value(pair_test->atomic_propositions, new_pair->atomic_propositions) == 0) {
if (snapshot_compare(pair_test, new_pair) == 0) {
}
xbt_dynar_insert_at(acceptance_pairs, min, &new_pair);
} else {
- pair_test = (mc_visited_pair_t) xbt_dynar_get_as(acceptance_pairs, index, mc_visited_pair_t);
+ pair_test = (simgrid::mc::VisitedPair*) xbt_dynar_get_as(acceptance_pairs, index, simgrid::mc::VisitedPair*);
if (pair_test->nb_processes < new_pair->nb_processes)
xbt_dynar_insert_at(acceptance_pairs, index + 1, &new_pair);
else if (pair_test->heap_bytes_used < new_pair->heap_bytes_used)
static void remove_acceptance_pair(int pair_num)
{
unsigned int cursor = 0;
- mc_visited_pair_t pair_test = nullptr;
+ simgrid::mc::VisitedPair* pair_test = nullptr;
int pair_found = 0;
xbt_dynar_foreach(acceptance_pairs, cursor, pair_test)
pair_test->acceptance_removed = 1;
if (_sg_mc_visited == 0 || pair_test->visited_removed == 1)
- MC_visited_pair_delete(pair_test);
+ simgrid::mc::visited_pair_delete(pair_test);
}
}
case 3:{
unsigned int cursor = 0;
xbt_automaton_propositional_symbol_t p = nullptr;
- xbt_dynar_foreach(_mc_property_automaton->propositional_symbols, cursor, p) {
+ xbt_dynar_foreach(simgrid::mc::property_automaton->propositional_symbols, cursor, p) {
if (std::strcmp(xbt_automaton_propositional_symbol_get_name(p), l->u.predicat) == 0)
return (int) xbt_dynar_get_as(atomic_propositions_values, cursor, int);
}
}
}
-static int MC_modelcheck_liveness_main(void);
-
static void MC_pre_modelcheck_liveness(void)
{
- mc_pair_t initial_pair = nullptr;
+ simgrid::mc::Pair* initial_pair = nullptr;
mc_model_checker->wait_for_requests();
- acceptance_pairs = xbt_dynar_new(sizeof(mc_visited_pair_t), nullptr);
+ acceptance_pairs = xbt_dynar_new(sizeof(simgrid::mc::VisitedPair*), nullptr);
if(_sg_mc_visited > 0)
- visited_pairs = xbt_dynar_new(sizeof(mc_visited_pair_t), nullptr);
+ simgrid::mc::visited_pairs = xbt_dynar_new(sizeof(simgrid::mc::VisitedPair*), nullptr);
initial_global_state->snapshot = simgrid::mc::take_snapshot(0);
initial_global_state->prev_pair = 0;
unsigned int cursor = 0;
xbt_automaton_state_t automaton_state;
- xbt_dynar_foreach(_mc_property_automaton->states, cursor, automaton_state) {
+ xbt_dynar_foreach(simgrid::mc::property_automaton->states, cursor, automaton_state) {
if (automaton_state->type == -1) { /* Initial automaton state */
- initial_pair = MC_pair_new();
+ initial_pair = simgrid::mc::pair_new();
initial_pair->automaton_state = automaton_state;
initial_pair->graph_state = MC_state_new();
initial_pair->atomic_propositions = get_atomic_propositions_values();
static int MC_modelcheck_liveness_main(void)
{
- mc_pair_t current_pair = nullptr;
+ simgrid::mc::Pair* current_pair = nullptr;
int value, res, visited_num = -1;
smx_simcall_t req = nullptr;
xbt_automaton_transition_t transition_succ = nullptr;
int cursor = 0;
- mc_pair_t next_pair = nullptr;
+ simgrid::mc::Pair* next_pair = nullptr;
xbt_dynar_t prop_values = nullptr;
- mc_visited_pair_t reached_pair = nullptr;
+ simgrid::mc::VisitedPair* reached_pair = nullptr;
while(xbt_fifo_size(mc_stack) > 0){
/* Get current pair */
- current_pair = (mc_pair_t) xbt_fifo_get_item_content(xbt_fifo_get_first_item(mc_stack));
+ current_pair = (simgrid::mc::Pair*) xbt_fifo_get_item_content(xbt_fifo_get_first_item(mc_stack));
/* Update current state in buchi automaton */
- _mc_property_automaton->current_state = current_pair->automaton_state;
+ simgrid::mc::property_automaton->current_state = current_pair->automaton_state;
XBT_DEBUG("********************* ( Depth = %d, search_cycle = %d, interleave size = %d, pair_num = %d, requests = %d)",
current_pair->depth, current_pair->search_cycle,
XBT_INFO("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
XBT_INFO("Counter-example that violates formula :");
MC_record_dump_path(mc_stack);
- MC_show_stack_liveness(mc_stack);
- MC_dump_stack_liveness(mc_stack);
+ simgrid::mc::show_stack_liveness(mc_stack);
+ simgrid::mc::dump_stack_liveness(mc_stack);
MC_print_statistics(mc_stats);
XBT_INFO("Counter-example depth : %d", counter_example_depth);
return SIMGRID_MC_EXIT_LIVENESS;
}
/* Pair already visited ? stop the exploration on the current path */
- if ((current_pair->exploration_started == 0) && (visited_num = is_visited_pair(reached_pair, current_pair)) != -1) {
+ if ((current_pair->exploration_started == 0)
+ && (visited_num = simgrid::mc::is_visited_pair(
+ reached_pair, current_pair)) != -1) {
if (dot_output != nullptr){
fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", initial_global_state->prev_pair, visited_num, initial_global_state->prev_req);
transition_succ = (xbt_automaton_transition_t)xbt_dynar_get_as(current_pair->automaton_state->out, cursor, xbt_automaton_transition_t);
res = MC_automaton_evaluate_label(transition_succ->label, prop_values);
if (res == 1 || res == 2) { /* 1 = True transition (always enabled), 2 = enabled transition according to atomic prop values */
- next_pair = MC_pair_new();
+ next_pair = simgrid::mc::pair_new();
next_pair->graph_state = MC_state_new();
next_pair->automaton_state = transition_succ->dst;
next_pair->atomic_propositions = get_atomic_propositions_values();
/* Traverse the stack backwards until a pair with a non empty interleave
set is found, deleting all the pairs that have it empty in the way. */
- while ((current_pair = (mc_pair_t) xbt_fifo_shift(mc_stack)) != nullptr) {
+ while ((current_pair = (simgrid::mc::Pair*) xbt_fifo_shift(mc_stack)) != nullptr) {
if (current_pair->requests > 0) {
/* We found a backtracking point */
XBT_DEBUG("Backtracking to depth %d", current_pair->depth);
XBT_DEBUG("Delete pair %d at depth %d", current_pair->num, current_pair->depth);
if (current_pair->automaton_state->type == 1)
remove_acceptance_pair(current_pair->num);
- MC_pair_delete(current_pair);
+ simgrid::mc::pair_delete(current_pair);
}
}
return SIMGRID_MC_EXIT_SUCCESS;
}
-int MC_modelcheck_liveness(void)
+namespace simgrid {
+namespace mc {
+
+int modelcheck_liveness(void)
{
if (mc_reduce_kind == e_mc_reduce_unset)
mc_reduce_kind = e_mc_reduce_none;
}
}
+}
SG_BEGIN_DECL()
-extern XBT_PRIVATE xbt_automaton_t _mc_property_automaton;
+SG_END_DECL()
+
+namespace simgrid {
+namespace mc {
-typedef struct XBT_PRIVATE s_mc_pair {
+extern XBT_PRIVATE xbt_automaton_t property_automaton;
+
+struct XBT_PRIVATE Pair {
int num;
int search_cycle;
mc_state_t graph_state; /* System state included */
int depth;
int exploration_started;
int visited_pair_removed;
-} s_mc_pair_t, *mc_pair_t;
+};
-typedef struct XBT_PRIVATE s_mc_visited_pair{
+struct XBT_PRIVATE VisitedPair {
int num;
int other_num; /* Dot output for */
int acceptance_pair;
int nb_processes;
int acceptance_removed;
int visited_removed;
-} s_mc_visited_pair_t, *mc_visited_pair_t;
+};
-XBT_PRIVATE mc_pair_t MC_pair_new(void);
-XBT_PRIVATE void MC_pair_delete(mc_pair_t);
-XBT_PRIVATE mc_visited_pair_t MC_visited_pair_new(int pair_num, xbt_automaton_state_t automaton_state, xbt_dynar_t atomic_propositions, mc_state_t graph_state);
-XBT_PRIVATE void MC_visited_pair_delete(mc_visited_pair_t p);
+XBT_PRIVATE simgrid::mc::Pair* pair_new(void);
+XBT_PRIVATE void pair_delete(simgrid::mc::Pair*);
+XBT_PRIVATE simgrid::mc::VisitedPair* visited_pair_new(int pair_num, xbt_automaton_state_t automaton_state, xbt_dynar_t atomic_propositions, mc_state_t graph_state);
+XBT_PRIVATE void visited_pair_delete(simgrid::mc::VisitedPair* p);
-int MC_modelcheck_liveness(void);
-XBT_PRIVATE void MC_show_stack_liveness(xbt_fifo_t stack);
-XBT_PRIVATE void MC_dump_stack_liveness(xbt_fifo_t stack);
+int modelcheck_liveness(void);
+XBT_PRIVATE void show_stack_liveness(xbt_fifo_t stack);
+XBT_PRIVATE void dump_stack_liveness(xbt_fifo_t stack);
XBT_PRIVATE extern xbt_dynar_t visited_pairs;
-XBT_PRIVATE int is_visited_pair(mc_visited_pair_t visited_pair, mc_pair_t pair);
+XBT_PRIVATE int is_visited_pair(simgrid::mc::VisitedPair* visited_pair, simgrid::mc::Pair* pair);
-SG_END_DECL()
+}
+}
#endif
#include "src/mc/mc_liveness.h"
#include "src/mc/mc_private.h"
-extern "C" {
+namespace simgrid {
+namespace mc {
-mc_pair_t MC_pair_new()
+simgrid::mc::Pair* pair_new()
{
- mc_pair_t p = nullptr;
- p = xbt_new0(s_mc_pair_t, 1);
+ simgrid::mc::Pair* p = nullptr;
+ p = xbt_new0(simgrid::mc::Pair, 1);
p->num = ++mc_stats->expanded_pairs;
p->exploration_started = 0;
p->search_cycle = 0;
return p;
}
-void MC_pair_delete(mc_pair_t p)
+void pair_delete(simgrid::mc::Pair* p)
{
p->automaton_state = nullptr;
if(p->visited_pair_removed)
}
}
+}
\ No newline at end of file
xbt_fifo_item_t item;
xbt_fifo_item_t start = xbt_fifo_get_last_item(stack);
for (item = start; item; item = xbt_fifo_get_prev_item(item)) {
- mc_pair_t pair = (mc_pair_t) xbt_fifo_get_item_content(item);
+ simgrid::mc::Pair* pair = (simgrid::mc::Pair*) xbt_fifo_get_item_content(item);
int value;
smx_simcall_t req = MC_state_get_executed_request(pair->graph_state, &value);
if (req && req->call != SIMCALL_NONE) {
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_visited, mc,
"Logging specific to state equaity detection mechanisms");
+}
+
+namespace simgrid {
+namespace mc {
+
xbt_dynar_t visited_pairs;
+
+}
+}
+
xbt_dynar_t visited_states;
static int is_exploration_stack_state(mc_visited_state_t state){
return new_state;
}
-mc_visited_pair_t MC_visited_pair_new(int pair_num, xbt_automaton_state_t automaton_state, xbt_dynar_t atomic_propositions, mc_state_t graph_state)
+namespace simgrid {
+namespace mc {
+
+simgrid::mc::VisitedPair* visited_pair_new(int pair_num, xbt_automaton_state_t automaton_state, xbt_dynar_t atomic_propositions, mc_state_t graph_state)
{
simgrid::mc::Process* process = &(mc_model_checker->process());
- mc_visited_pair_t pair = nullptr;
- pair = xbt_new0(s_mc_visited_pair_t, 1);
+ simgrid::mc::VisitedPair* pair = nullptr;
+ pair = xbt_new0(simgrid::mc::VisitedPair, 1);
pair->graph_state = graph_state;
if(pair->graph_state->system_state == nullptr)
pair->graph_state->system_state = simgrid::mc::take_snapshot(pair_num);
return pair;
}
-static int is_exploration_stack_pair(mc_visited_pair_t pair){
+static int is_exploration_stack_pair(simgrid::mc::VisitedPair* pair){
xbt_fifo_item_t item = xbt_fifo_get_first_item(mc_stack);
while (item) {
- if (((mc_pair_t)xbt_fifo_get_item_content(item))->num == pair->num){
- ((mc_pair_t)xbt_fifo_get_item_content(item))->visited_pair_removed = 1;
+ if (((simgrid::mc::Pair*)xbt_fifo_get_item_content(item))->num == pair->num){
+ ((simgrid::mc::Pair*)xbt_fifo_get_item_content(item))->visited_pair_removed = 1;
return 1;
}
item = xbt_fifo_get_next_item(item);
return 0;
}
-void MC_visited_pair_delete(mc_visited_pair_t p)
+void visited_pair_delete(simgrid::mc::VisitedPair* p)
{
p->automaton_state = nullptr;
if( !is_exploration_stack_pair(p))
p = nullptr;
}
+}
+}
+
/**
* \brief Find a suitable subrange of candidate duplicates for a given state
* \param list dynamic array of states/pairs with candidate duplicates of the current state;
void *ref_test;
if (_sg_mc_liveness) {
- nb_processes = ((mc_visited_pair_t) ref)->nb_processes;
- heap_bytes_used = ((mc_visited_pair_t) ref)->heap_bytes_used;
+ nb_processes = ((simgrid::mc::VisitedPair*) ref)->nb_processes;
+ heap_bytes_used = ((simgrid::mc::VisitedPair*) ref)->heap_bytes_used;
} else {
nb_processes = ((mc_visited_state_t) ref)->nb_processes;
heap_bytes_used = ((mc_visited_state_t) ref)->heap_bytes_used;
while (start <= end) {
cursor = (start + end) / 2;
if (_sg_mc_liveness) {
- ref_test = (mc_visited_pair_t) xbt_dynar_get_as(list, cursor, mc_visited_pair_t);
- nb_processes_test = ((mc_visited_pair_t) ref_test)->nb_processes;
- heap_bytes_used_test = ((mc_visited_pair_t) ref_test)->heap_bytes_used;
+ ref_test = (simgrid::mc::VisitedPair*) xbt_dynar_get_as(list, cursor, simgrid::mc::VisitedPair*);
+ nb_processes_test = ((simgrid::mc::VisitedPair*) ref_test)->nb_processes;
+ heap_bytes_used_test = ((simgrid::mc::VisitedPair*) ref_test)->heap_bytes_used;
} else {
ref_test = (mc_visited_state_t) xbt_dynar_get_as(list, cursor, mc_visited_state_t);
nb_processes_test = ((mc_visited_state_t) ref_test)->nb_processes;
previous_cursor = cursor - 1;
while (previous_cursor >= 0) {
if (_sg_mc_liveness) {
- ref_test = (mc_visited_pair_t) xbt_dynar_get_as(list, previous_cursor, mc_visited_pair_t);
- nb_processes_test = ((mc_visited_pair_t) ref_test)->nb_processes;
- heap_bytes_used_test = ((mc_visited_pair_t) ref_test)->heap_bytes_used;
+ ref_test = (simgrid::mc::VisitedPair*) xbt_dynar_get_as(list, previous_cursor, simgrid::mc::VisitedPair*);
+ nb_processes_test = ((simgrid::mc::VisitedPair*) ref_test)->nb_processes;
+ heap_bytes_used_test = ((simgrid::mc::VisitedPair*) ref_test)->heap_bytes_used;
} else {
ref_test = (mc_visited_state_t) xbt_dynar_get_as(list, previous_cursor, mc_visited_state_t);
nb_processes_test = ((mc_visited_state_t) ref_test)->nb_processes;
size_t next_cursor = cursor + 1;
while (next_cursor < xbt_dynar_length(list)) {
if (_sg_mc_liveness) {
- ref_test = (mc_visited_pair_t) xbt_dynar_get_as(list, next_cursor, mc_visited_pair_t);
- nb_processes_test = ((mc_visited_pair_t) ref_test)->nb_processes;
- heap_bytes_used_test = ((mc_visited_pair_t) ref_test)->heap_bytes_used;
+ ref_test = (simgrid::mc::VisitedPair*) xbt_dynar_get_as(list, next_cursor, simgrid::mc::VisitedPair*);
+ nb_processes_test = ((simgrid::mc::VisitedPair*) ref_test)->nb_processes;
+ heap_bytes_used_test = ((simgrid::mc::VisitedPair*) ref_test)->heap_bytes_used;
} else {
ref_test = (mc_visited_state_t) xbt_dynar_get_as(list, next_cursor, mc_visited_state_t);
nb_processes_test = ((mc_visited_state_t) ref_test)->nb_processes;
return nullptr;
}
+namespace simgrid {
+namespace mc {
+
/**
* \brief Checks whether a given pair has already been visited by the algorithm.
*/
-int is_visited_pair(mc_visited_pair_t visited_pair, mc_pair_t pair) {
+int is_visited_pair(simgrid::mc::VisitedPair* visited_pair, simgrid::mc::Pair* pair) {
if (_sg_mc_visited == 0)
return -1;
- mc_visited_pair_t new_visited_pair = nullptr;
+ simgrid::mc::VisitedPair* new_visited_pair = nullptr;
if (visited_pair == nullptr)
- new_visited_pair = MC_visited_pair_new(pair->num, pair->automaton_state, pair->atomic_propositions, pair->graph_state);
+ new_visited_pair = simgrid::mc::visited_pair_new(
+ pair->num, pair->automaton_state, pair->atomic_propositions,
+ pair->graph_state);
else
new_visited_pair = visited_pair;
int min = -1, max = -1, index;
//int res;
- mc_visited_pair_t pair_test;
+ simgrid::mc::VisitedPair* pair_test;
int cursor;
index = get_search_interval(visited_pairs, new_visited_pair, &min, &max);
if (min != -1 && max != -1) { // Visited pair with same number of processes and same heap bytes used exists
/*res = xbt_parmap_mc_apply(parmap, snapshot_compare, xbt_dynar_get_ptr(visited_pairs, min), (max-min)+1, pair);
if(res != -1){
- pair_test = (mc_pair_t)xbt_dynar_get_as(visited_pairs, (min+res)-1, mc_pair_t);
+ pair_test = (simgrid::mc::Pair*)xbt_dynar_get_as(visited_pairs, (min+res)-1, simgrid::mc::Pair*);
if(pair_test->other_num == -1)
pair->other_num = pair_test->num;
else
if(pair_test->stack_removed && pair_test->visited_removed){
if((pair_test->automaton_state->type == 1) || (pair_test->automaton_state->type == 2)){
if(pair_test->acceptance_removed){
- MC_pair_delete(pair_test);
+ simgrid::mc::pair_delete(pair_test);
}
}else{
- MC_pair_delete(pair_test);
+ simgrid::mc::pair_delete(pair_test);
}
}
return pair->other_num;
} */
cursor = min;
while (cursor <= max) {
- pair_test = (mc_visited_pair_t) xbt_dynar_get_as(visited_pairs, cursor, mc_visited_pair_t);
+ pair_test = (simgrid::mc::VisitedPair*) xbt_dynar_get_as(visited_pairs, cursor, simgrid::mc::VisitedPair*);
if (xbt_automaton_state_compare(pair_test->automaton_state, new_visited_pair->automaton_state) == 0) {
if (xbt_automaton_propositional_symbols_compare_value(pair_test->atomic_propositions, new_visited_pair->atomic_propositions) == 0) {
if (snapshot_compare(pair_test, new_visited_pair) == 0) {
pair_test->visited_removed = 1;
if (!pair_test->acceptance_pair
|| pair_test->acceptance_removed == 1)
- MC_visited_pair_delete(pair_test);
+ simgrid::mc::visited_pair_delete(pair_test);
return new_visited_pair->other_num;
}
}
}
xbt_dynar_insert_at(visited_pairs, min, &new_visited_pair);
} else {
- pair_test = (mc_visited_pair_t) xbt_dynar_get_as(visited_pairs, index, mc_visited_pair_t);
+ pair_test = (simgrid::mc::VisitedPair*) xbt_dynar_get_as(visited_pairs, index, simgrid::mc::VisitedPair*);
if (pair_test->nb_processes < new_visited_pair->nb_processes)
xbt_dynar_insert_at(visited_pairs, index + 1, &new_visited_pair);
else if (pair_test->heap_bytes_used < new_visited_pair->heap_bytes_used)
xbt_dynar_remove_at(visited_pairs, index2, &pair_test);
pair_test->visited_removed = 1;
if (!pair_test->acceptance_pair || pair_test->acceptance_removed)
- MC_visited_pair_delete(pair_test);
+ simgrid::mc::visited_pair_delete(pair_test);
}
return -1;
}
}
+}
\ No newline at end of file
else if (!_sg_mc_property_file || _sg_mc_property_file[0] == '\0')
res = MC_modelcheck_safety();
else
- res = MC_modelcheck_liveness();
+ res = simgrid::mc::modelcheck_liveness();
mc_model_checker->shutdown();
return res;
}
