be_ptr
bmc_tableauGetEventuallyAtTime(const BeEnc_ptr be_enc,
const node_ptr ltl_wff,
const int intime, const int k, const int l)
{
Be_Manager_ptr be_mgr;
int time;
be_ptr tableau;
int stop_time;
int start_time;
nusmv_assert((intime < k) || (intime==k && Bmc_Utils_IsNoLoopback(l)) );
/* checks out the validity of [l, k] only if a loop exists: */
nusmv_assert(Bmc_Utils_IsNoLoopback(l) || (k > l));
be_mgr = BeEnc_get_be_manager(be_enc);
tableau = Be_Falsity(be_mgr);
/* there exist three cases:
1) no loop: iterates from k downto intime;
2) loop, (intime < l): iterates from k-1 downto intime;
3) loop, (l <= intime < k) : iterates from k-1 downto l */
if (Bmc_Utils_IsNoLoopback(l)) {
/* The first case */
start_time = k;
stop_time = intime;
}
else {
/* The second and third case*/
start_time = k-1;
stop_time = min(intime,l);
}
for (time = start_time; time>=stop_time; --time) {
/* lazy evaluation: */
be_ptr tableau_at_time = BmcInt_Tableau_GetAtTime(be_enc, ltl_wff,
time, k, l);
if ( Be_IsTrue(be_mgr, tableau_at_time) ) {
tableau = tableau_at_time;
break;
}
tableau = Be_Or(be_mgr,
tableau_at_time, tableau);
} /* loop */
return tableau;
}
/**Function********************************************************************
Synopsis [SAT Based Incremental simulation]
Description [This function performs incremental sat based
simulation up to <tt>target_steps</tt>.
Simulation starts from an initial state internally selected.
It accepts a constraint to direct the simulation to paths satisfying
such constraints. The constraints is assumed to be over state, input
and next state variables. Thus, please carefully consider this
information while providing constraints to this routine.
The simulation stops if either the <tt>target_steps</tt> steps of
simulation have been performed, or the simulation bumped in a
deadlock (that might be due to the constraints that are too strong).
Parameters:
'print_trace' : shows the generated trace
'changes_only' : shows only variables that actually change value
between one step and it's next one]
SideEffects [The possibly partial generated simulaiton trace
is added to the trace manager for possible reuse.]
SeeAlso [optional]
******************************************************************************/
int Bmc_StepWiseSimulation(BeFsm_ptr be_fsm,
BddEnc_ptr bdd_enc,
TraceManager_ptr trace_manager,
int target_steps,
be_ptr constraints,
boolean time_shift,
boolean print_trace,
boolean changes_only,
Simulation_Mode mode,
boolean display_all)
{
#if NUSMV_HAVE_INCREMENTAL_SAT
int steps;
boolean no_deadlock;
BeEnc_ptr be_enc = BE_ENC(NULL);
Be_Manager_ptr be_mgr = (Be_Manager_ptr)NULL;
SatIncSolver_ptr solver = SAT_INC_SOLVER(NULL);
SatSolverGroup satGrp = (SatSolverGroup)-1;
SatSolverResult satResult = SAT_SOLVER_UNAVAILABLE;
Trace_ptr trace = bmc_simulate_get_curr_sim_trace();
int tr_num = bmc_simulate_get_curr_sim_trace_index();
be_ptr be_trans = (be_ptr)NULL;
long time_statistics = util_cpu_time();
TRACE_CHECK_INSTANCE(trace); /* a trace was picked */
if (target_steps <= 0) return -1;
/* Create the SAT solver instance */
solver = Sat_CreateIncSolver(get_sat_solver(OptsHandler_get_instance()));
if (SAT_INC_SOLVER(NULL) == solver) {
fprintf(nusmv_stderr,
"Incremental sat solver '%s' is not available.\n",
get_sat_solver(OptsHandler_get_instance()));
return -1;
}
switch (mode) {
case Random:
bmc_simulate_enable_random_mode(SAT_SOLVER(solver));
break;
case Interactive:
/* Do nothing */
break;
case Deterministic:
/* Do nothing */
break;
default:
internal_error("%s: Invalid mode given", __func__);
}
no_deadlock = true;
be_enc = BeFsm_get_be_encoding(be_fsm);
be_mgr = BeEnc_get_be_manager(be_enc);
/* 1. Add the transition relation into the solver permanently */
be_trans = BeFsm_get_invar(be_fsm);
be_trans = Be_And(be_mgr,
be_trans,
BeEnc_shift_curr_to_next(be_enc, be_trans));
be_trans = Be_And(be_mgr, BeFsm_get_trans(be_fsm), be_trans);
/* We force the constraints that can be over starting states, or
over next states, or over the input. If the constraint is over
the current state variables, then it might be the case the chosen
next statre does not satisfy the constraint. */
if (time_shift) {
constraints = BeEnc_shift_curr_to_next(be_enc, constraints);
}
be_trans = Be_And(be_mgr, be_trans, constraints);
/* Necessary to re-use the routines for extracting the model */
be_trans = BeEnc_untimed_expr_to_timed(be_enc, be_trans, 0);
bmc_simulate_add_be_into_inc_solver_positively(SAT_INC_SOLVER(solver),
SatSolver_get_permanent_group(SAT_SOLVER(solver)),
be_trans, be_enc);
/* 2. Iteration adding last computed state as src state and
extracting the pair (input,next_state), adding the pair to the
computed trace, and then iterating from the so far computed
next_state */
{
for (steps = 0; ((steps < target_steps) && no_deadlock) ; steps++) {
be_ptr be_src_state = (be_ptr)NULL;
if (opt_verbose_level_gt(OptsHandler_get_instance(), 1)) {
fprintf(nusmv_stderr, "Performing simulation step %d ...", steps+1);
}
/* 2.0. Extraction from the so far compute trace the last
state. */
be_src_state = BeEnc_untimed_expr_to_timed(be_enc,
TraceUtils_fetch_as_be(trace, Trace_last_iter(trace),
TRACE_ITER_SF_VARS, be_enc, bdd_enc), 0);
/* 2.2 Create the group to store the last state and, add the
last state to the solver */
satGrp = SatIncSolver_create_group(solver);
bmc_simulate_add_be_into_inc_solver_positively(SAT_INC_SOLVER(solver),
satGrp,
be_src_state, be_enc);
/* 2.3. Call the solver on the instantiated problem */
satResult = SatSolver_solve_all_groups(SAT_SOLVER(solver));
switch (satResult) {
case SAT_SOLVER_SATISFIABLE_PROBLEM:
if (Interactive == mode) {
Trace_ptr iTrace =
bmc_simulate_interactive_step(SAT_SOLVER(solver), be_enc,
bdd_enc, Trace_get_symbols(trace),
true, display_all);
Trace_concat(trace, &iTrace);
}
else {
/* Append current computed state to the trace */
bmc_trace_utils_append_input_state(trace, be_enc,
SatSolver_get_model(SAT_SOLVER(solver)));
}
break;
case SAT_SOLVER_UNSATISFIABLE_PROBLEM:
fprintf(nusmv_stderr,
"The model reached a deadlock state: iteration %d.\n", steps);
if (!Be_IsTrue(be_mgr, constraints)) {
fprintf(nusmv_stderr,
"This might be due to the constraints that are too strong.\n");
}
no_deadlock = false;
break;
default:
fprintf(nusmv_stderr,
"At iteration %d, the solver returned an unexpected value: %d\n",
steps, satResult);
no_deadlock = false;
break;
}
/* 2.4. Remove and destroy the group containing the last
computed state */
SatIncSolver_destroy_group(solver, satGrp);
if (opt_verbose_level_gt(OptsHandler_get_instance(), 1)) {
fprintf(nusmv_stderr, "... done\n");
}
if (opt_verbose_level_gt(OptsHandler_get_instance(), 0)) {
fprintf(nusmv_stdout,
" -- simulation of step %d has finished in %2.1f seconds\n",
steps, (util_cpu_time() - time_statistics) / 1000.0);
time_statistics = util_cpu_time();
}
} /* (steps < target_steps) && no_deadlock) */
} /* iteration block */
/* 3. We clean the memory and we return */
SatIncSolver_destroy(solver);
if (no_deadlock && print_trace) {
TraceManager_execute_plugin(trace_manager, TRACE_OPT(NULL),
(changes_only) ? 0 : 1, tr_num);
}
return steps;
#else
fprintf(nusmv_stderr,
"%s: Relies on Incremental solving. "
"No incremental SAT solver is available now\n", __func__);
return -1;
#endif
}
/**Function********************************************************************
Synopsis [Performs simulation]
Description [Generate a problem with no property, and search for a
solution, appending it to the current simulation trace.
Returns 1 if solver could not be created, 0 if everything went smooth]
SideEffects [None]
SeeAlso []
******************************************************************************/
int Bmc_Simulate(const BeFsm_ptr be_fsm, BddEnc_ptr bdd_enc,
be_ptr be_constraints, boolean time_shift,
const int k, const boolean print_trace,
const boolean changes_only,
const Simulation_Mode mode)
{
be_ptr init, prob; /* The problem in BE format */
SatSolver_ptr solver;
SatSolverResult sat_res;
BeEnc_ptr be_enc;
Be_Manager_ptr be_mgr;
Be_Cnf_ptr cnf;
Trace_ptr trace = bmc_simulate_get_curr_sim_trace();
int tr_num = bmc_simulate_get_curr_sim_trace_index();
TRACE_CHECK_INSTANCE(trace); /* curr trace was picked */
be_enc = BeFsm_get_be_encoding(be_fsm);
be_mgr = BeEnc_get_be_manager(be_enc);
if (opt_verbose_level_gt(OptsHandler_get_instance(), 0)) {
fprintf(nusmv_stderr, "Simulation of length %d (no loopback)\n", k);
}
solver = Sat_CreateNonIncSolver(get_sat_solver(OptsHandler_get_instance()));
if (solver == SAT_SOLVER(NULL)) {
fprintf(nusmv_stderr,
"Non-incremental sat solver '%s' is not available.\n",
get_sat_solver(OptsHandler_get_instance()));
return 1;
}
switch (mode) {
case Random:
bmc_simulate_enable_random_mode(SAT_SOLVER(solver));
break;
case Interactive:
internal_error("%s: Interactive mode not supported yet", __func__);
break;
case Deterministic:
/* Do nothing */
break;
default:
internal_error("%s: Invalid mode given", __func__);
}
/* starting state taken from the last node of the current sim trace */
init = BeEnc_untimed_expr_to_timed(be_enc,
TraceUtils_fetch_as_be(trace, Trace_last_iter(trace),
TRACE_ITER_SF_VARS, be_enc, bdd_enc), 0);
prob = Be_And(be_mgr, Bmc_Model_GetPathNoInit(be_fsm, k), init);
/* Use constraints only if actually necessary */
if (!Be_IsTrue(be_mgr, be_constraints)) {
int i;
for (i = 0; i <= k; ++i) {
be_ptr be_timed = be_constraints;
if (time_shift) {
be_timed = BeEnc_shift_curr_to_next(be_enc, be_timed);
}
be_timed = BeEnc_untimed_expr_to_timed(be_enc, be_timed, i);
prob = Be_And(be_mgr, prob, be_timed);
}
}
prob = Bmc_Utils_apply_inlining(be_mgr, prob);
cnf = Be_ConvertToCnf(be_mgr, prob, 1);
SatSolver_add(solver, cnf, SatSolver_get_permanent_group(solver));
SatSolver_set_polarity(solver, cnf, 1,
SatSolver_get_permanent_group(solver));
sat_res = SatSolver_solve_all_groups(solver);
/* Processes the result: */
switch (sat_res) {
case SAT_SOLVER_UNSATISFIABLE_PROBLEM:
fprintf(nusmv_stdout,
"The model deadlocks before requested length %d!\n", k);
break;
case SAT_SOLVER_SATISFIABLE_PROBLEM:
{
BoolSexpFsm_ptr bsexp_fsm; /* needed for trace language */
bsexp_fsm = \
PropDb_master_get_bool_sexp_fsm(PropPkg_get_prop_database());
BOOL_SEXP_FSM_CHECK_INSTANCE(bsexp_fsm);
Trace_ptr extension = \
Bmc_create_trace_from_cnf_model(be_enc,
SexpFsm_get_symbols_list(SEXP_FSM(bsexp_fsm)), NIL(char),
TRACE_TYPE_UNSPECIFIED,
SatSolver_get_model(solver), k);
trace = Trace_concat(trace, &extension);
nusmv_assert(TRACE(NULL) == extension);
if (print_trace) {
TraceManager_execute_plugin(global_trace_manager, TRACE_OPT(NULL),
(changes_only) ? 0 : 1, tr_num);
}
break;
} /* SAT */
case SAT_SOLVER_INTERNAL_ERROR:
internal_error("Sorry, solver answered with a fatal Internal "
"Failure during problem solving.\n");
case SAT_SOLVER_TIMEOUT:
case SAT_SOLVER_MEMOUT:
internal_error("Sorry, solver ran out of resources and aborted "
"the execution.\n");
default:
internal_error(" Bmc_Simulate: Unexpected value in sat result");
} /* switch */
/* cleanup */
SatSolver_destroy(solver);
Be_Cnf_Delete(cnf);
return 0;
}
