void
ndfs_blue_handle (void *arg, state_info_t *successor, transition_info_t *ti,
int seen)
{
wctx_t *ctx = (wctx_t *) arg;
alg_local_t *loc = ctx->local;
nndfs_color_t color = nn_get_color (&loc->color_map, successor->ref);
if (proviso == Proviso_Stack)
ti->por_proviso = !nn_color_eq(color, NNCYAN);
/**
* The following lines bear little resemblance to the algorithms in the
* respective papers (NNDFS / LNDFS), but we must store all non-red states
* on the stack here, in order to calculate all-red correctly later.
*/
if ( ecd && nn_color_eq(color, NNCYAN) &&
(GBbuchiIsAccepting(ctx->model, state_info_state(ctx->state)) ||
GBbuchiIsAccepting(ctx->model, state_info_state(successor))) ) {
/* Found cycle in blue search */
ndfs_report_cycle (ctx->run, ctx->model, loc->stack, successor);
} else if ((loc->strat == Strat_LNDFS && !state_store_has_color(ctx->state->ref, GRED, loc->rec_bits)) ||
(loc->strat != Strat_LNDFS && !nn_color_eq(color, NNPINK))) {
raw_data_t stack_loc = dfs_stack_push (loc->stack, NULL);
state_info_serialize (successor, stack_loc);
}
(void) ti; (void) seen;
}
static void
endfs_handle_dangerous (wctx_t *ctx)
{
alg_local_t *loc = ctx->local;
cndfs_alg_local_t *cloc = (cndfs_alg_local_t *) ctx->local;
while ( dfs_stack_size(cloc->in_stack) ) {
raw_data_t state_data = dfs_stack_pop (cloc->in_stack);
state_info_deserialize (ctx->state, state_data);
if ( !state_store_has_color(ctx->state->ref, GDANGEROUS, loc->rec_bits) &&
ctx->state->ref != loc->seed->ref )
if (update_color(ctx, ctx->state->ref, CRED, 1))
loc->red_work.explored++;
}
if (update_color(ctx, ctx->state->ref, CRED, 1)) {
loc->red_work.explored++;
loc->counters.accepting++;
}
if ( state_store_has_color(loc->seed->ref, GDANGEROUS, loc->rec_bits) ) {
rec_ndfs_call (ctx, loc->seed->ref);
}
}
static void
tarjan_handle (void *arg, state_info_t *successor, transition_info_t *ti,
int seen)
{
// parent state is ctx->state
wctx_t *ctx = (wctx_t *) arg;
alg_local_t *loc = ctx->local;
raw_data_t *addr;
hash32_t hash;
int found;
ctx->counters->trans++;
// self-loop
if (ctx->state->ref == successor->ref)
return;
// completed SCC
if (state_store_has_color (successor->ref, SCC_STATE, 0))
return;
hash = ref_hash (successor->ref);
found = fset_find (loc->visited_states, &hash, &successor->ref,
(void **)&addr, false);
if (found) {
// previously visited state ==> update lowlink
state_info_deserialize (loc->target, *addr);
if (loc->state_tarjan.lowlink > loc->target_tarjan.lowlink)
loc->state_tarjan.lowlink = loc->target_tarjan.lowlink;
} else {
// unseen state ==> push to search_stack
raw_data_t stack_loc = dfs_stack_push (loc->search_stack, NULL);
state_info_serialize (successor, stack_loc);
}
(void) ti; (void) seen;
}
static void
ndfs_red_handle (void *arg, state_info_t *successor, transition_info_t *ti,
int seen)
{
wctx_t *ctx = (wctx_t *) arg;
alg_local_t *loc = ctx->local;
nndfs_color_t color = nn_get_color(&loc->color_map, successor->ref);
ti->por_proviso = 1; // only visit blue states to stay in reduced search space
if (proviso != Proviso_None && !nn_color_eq(color, NNBLUE))
return; // only revisit blue states to determinize POR
if ( nn_color_eq(color, NNCYAN) ) {
/* Found cycle back to the stack */
ndfs_report_cycle (ctx->run, ctx->model, loc->stack, successor);
} else if ( nn_color_eq(color, NNBLUE) && (loc->strat != Strat_LNDFS ||
!state_store_has_color(ctx->state->ref, GRED, loc->rec_bits)) ) {
raw_data_t stack_loc = dfs_stack_push (loc->stack, NULL);
state_info_serialize (successor, stack_loc);
}
(void) ti; (void) seen;
}
void
tarjan_run (run_t *run, wctx_t *ctx)
{
alg_local_t *loc = ctx->local;
raw_data_t *addr;
raw_data_t state_data;
bool on_stack;
hash32_t hash;
#ifdef HAVE_PROFILER
Warning (info, "Using the profiler");
ProfilerStart ("tarjan.perf");
#endif
#ifdef SEARCH_COMPLETE_GRAPH
int init_state = dlopen_get_worker_initial_state (ctx->id, W);
int inits = 0;
// loop until every state of the graph has been visited
while ( 1 )
{
inits ++;
// use loc->target as a dummy for the initial state
loc->target->ref = init_state;
#endif
tarjan_init (ctx);
// continue until we are done exploring the graph
while ( !run_is_stopped (run) ) {
state_data = dfs_stack_top (loc->search_stack);
if (state_data != NULL) {
// there is a state on the current stackframe ==> explore it
state_info_deserialize (ctx->state, state_data);
// pop the state and continue if it is part of a completed SCC
if (state_store_has_color (ctx->state->ref, SCC_STATE, 0)) {
dfs_stack_pop (loc->search_stack);
continue;
}
hash = ref_hash (ctx->state->ref);
on_stack = fset_find (loc->visited_states, &hash,
&ctx->state->ref, (void **) &addr, true);
if (!on_stack) {
// unseen state ==> initialize and explore
HREassert (loc->cnt.tarjan_counter != UINT32_MAX);
loc->cnt.tarjan_counter ++;
loc->state_tarjan.index = loc->cnt.tarjan_counter;
loc->state_tarjan.lowlink = loc->cnt.tarjan_counter;
// point visited_states data to stack
*addr = state_data;
explore_state (ctx);
state_info_serialize (ctx->state, state_data);
} else {
// previously visited state ==> update parent
// NB: state is on tarjan_stack
state_info_deserialize (ctx->state, *addr);
update_parent (ctx, loc->state_tarjan.lowlink);
dfs_stack_pop (loc->search_stack);
}
} else {
// there is no state on the current stackframe ==> backtrack
// we are done if we backtrack from the initial state
if (0 == dfs_stack_nframes (loc->search_stack))
break;
// leave the stackframe
dfs_stack_leave (loc->search_stack);
ctx->counters->level_cur--;
// retrieve the parent state from search_stack (to be removed)
state_data = dfs_stack_top (loc->search_stack);
state_info_deserialize (ctx->state, state_data);
Debug ("Backtracking %zu (%d, %d)", ctx->state->ref,
loc->state_tarjan.index, loc->state_tarjan.lowlink);
if (loc->state_tarjan.index == loc->state_tarjan.lowlink) {
// index == lowlink ==> root of the SCC ==> report the SCC
pop_scc (ctx, ctx->state->ref, loc->state_tarjan.lowlink);
} else {
// lowlink < index ==> LIVE SCC ==> move to tarjan_stack
move_tarjan (ctx, ctx->state, state_data);
update_parent (ctx, loc->state_tarjan.lowlink);
}
dfs_stack_pop (loc->search_stack);
}
}
#ifdef SEARCH_COMPLETE_GRAPH
init_state = dlopen_get_new_initial_state (init_state);
if (init_state == -1) {
Warning(info, "Number of inits : %d", inits);
break;
}
}
#endif
#ifdef HAVE_PROFILER
Warning(info, "Done profiling");
ProfilerStop();
#endif
if (!run_is_stopped(run) && dfs_stack_size(loc->tarjan_stack) != 0)
Warning (info, "Tarjan stack not empty: %zu (stack %zu)",
dfs_stack_size(loc->tarjan_stack),
dfs_stack_size(loc->search_stack));
if (!run_is_stopped(run) && fset_count(loc->visited_states) != 0)
Warning (info, "Stack-set not empty: %zu",
fset_count(loc->visited_states));
}
