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 ta_queue_state_normal (wctx_t *ctx, state_info_t *successor) { alg_global_t *sm = ctx->global; raw_data_t stack_loc = dfs_stack_push (sm->stack, NULL); state_info_serialize (successor, stack_loc); }
static void endfs_handle_all (void *arg, state_info_t *successor, transition_info_t *ti, int seen) { wctx_t *ctx = (wctx_t *) arg; alg_local_t *loc = ctx->local; raw_data_t stack_loc = dfs_stack_push (loc->stack, NULL); state_info_serialize (successor, stack_loc); ti->por_proviso = 0; (void) seen; }
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 endfs_handle_red (void *arg, state_info_t *successor, transition_info_t *ti, int seen) { wctx_t *ctx = (wctx_t *) arg; alg_local_t *loc = ctx->local; cndfs_alg_local_t *cloc = (cndfs_alg_local_t *) ctx->local; int onstack; /* Find cycle back to the seed */ HREassert (cloc->accepting_depth > 0); size_t *level; onstack = ctx->state->ref == loc->seed->ref; if (!onstack) { onstack = fset_find (cloc->pink, NULL, &successor->ref, (void**)&level, false); HREassert (onstack != FSET_FULL); } if ( onstack && *level < cloc->accepting_depth ) ndfs_report_cycle (ctx, ctx->model, loc->stack, successor); /* Mark states dangerous if necessary */ if ( Strat_ENDFS == loc->strat && pins_state_is_accepting(ctx->model, state_info_state(successor)) && state_store_get_colors (successor->ref) != CRED ) state_store_try_color(successor->ref, GDANGEROUS, loc->rec_bits); if ( !onstack && state_store_get_colors (successor->ref) != CRED ) { raw_data_t stack_loc = dfs_stack_push (loc->stack, NULL); state_info_serialize (successor, stack_loc); } // check proviso if (PINS_POR && proviso == Proviso_CNDFS && cloc->successors == NONEC) { if (ti->por_proviso != 0) { // state already fully expanded cloc->successors = SRCINV; } else if (onstack) { // cycle check if (onstack) cloc->successors = CYCLE; } // avoid full exploration (proviso is enforced later in backtrack) ti->por_proviso = 1; // avoid full exploration } (void) seen; }
/** * move a search_stack state to the tarjan_stack */ static void move_tarjan (wctx_t *ctx, state_info_t *state, raw_data_t state_data) { alg_local_t *loc = ctx->local; raw_data_t *addr; hash32_t hash; int found; // add state to tarjan_stack raw_data_t tarjan_loc = dfs_stack_push (loc->tarjan_stack, NULL); state_info_serialize (state, tarjan_loc); // Update reference to the new stack hash = ref_hash (state->ref); found = fset_find (loc->visited_states, &hash, &state->ref, (void**) &addr, false); HREassert (*addr == state_data, "Wrong addr?"); HREassert (found, "Could not find key in set"); *addr = tarjan_loc; }
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; }
/** * update lowlink for the parent (top of previous stackframe in search_stack) */ static void update_parent (wctx_t *ctx, uint32_t low_child) { alg_local_t *loc = ctx->local; raw_data_t state_data; // the initial state has no parent if (dfs_stack_nframes (loc->search_stack) == 0) return; // store the top of the previous stackframe to loc->target state_data = dfs_stack_peek_top (loc->search_stack, 1); state_info_deserialize (loc->target, state_data); if (loc->target_tarjan.lowlink > low_child) { Debug ("Updating %zu from low %d --> %d", loc->target->ref, loc->target_tarjan.lowlink, low_child); loc->target_tarjan.lowlink = low_child; state_info_serialize (loc->target, state_data); } }
static void endfs_handle_blue (void *arg, state_info_t *successor, transition_info_t *ti, int seen) { wctx_t *ctx = (wctx_t *) arg; alg_local_t *loc = ctx->local; cndfs_alg_local_t *cloc = (cndfs_alg_local_t *) ctx->local; size_t *level; int onstack = fset_find (cloc->pink, NULL, &successor->ref, (void**)&level, false); HREassert (onstack != FSET_FULL); /** * The following lines bear little resemblance to the algorithms in the * respective papers (Evangelista et al./ Laarman et al.), but we must * store all non-red states on the stack in order to calculate * all-red correctly later. Red states are also stored as optimization. */ if ( ecd && onstack && *level < cloc->accepting_depth) { /* Found cycle in blue search */ ndfs_report_cycle (ctx, ctx->model, loc->stack, successor); } else if ( all_red || (!onstack && state_store_get_colors (successor->ref) != CBLUE) ) { raw_data_t stack_loc = dfs_stack_push (loc->stack, NULL); state_info_serialize (successor, stack_loc); } // check proviso if (PINS_POR && proviso == Proviso_CNDFS && cloc->successors == NONEC) { if (ti->por_proviso != 0) { // state already fully expanded cloc->successors = SRCINV; } else if (onstack) { // check cycle cloc->successors = CYCLE; } // avoid full exploration (proviso is enforced later in backtrack) ti->por_proviso = 1; } (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)); }