mirror of
https://github.com/Z3Prover/z3
synced 2025-04-07 18:05:21 +00:00
Almost cleaned up version.
This commit is contained in:
parent
c56e55b230
commit
de028e7a30
|
@ -22,167 +22,13 @@ Notes:
|
|||
#ifndef _SLS_COMPILATION_SETTINGS_H_
|
||||
#define _SLS_COMPILATION_SETTINGS_H_
|
||||
|
||||
// which unsatisfied assertion is selected? only works with _FOCUS_ > 0
|
||||
// 0 = random, 1 = #moves, 2 = assertion with min score, 3 = assertion with max score
|
||||
#define _BFS_ 0
|
||||
|
||||
// how many terms are considered for variable selection?
|
||||
// 0 = all terms (GSAT), 1 = only one top level assertion (WSAT), 2 = only one bottom level atom
|
||||
#define _FOCUS_ 1
|
||||
|
||||
// probability of choosing the same assertion again in the next step
|
||||
#define _PERC_STICKY_ 0
|
||||
|
||||
// do we use dirty unit propagation to get rid of nested top level assertions?
|
||||
#define _DIRTY_UP_ 0
|
||||
|
||||
// shall we use additive weighting scheme?
|
||||
#define _PAWS_ 5
|
||||
#define _PAWS_INIT_ 40
|
||||
|
||||
// do we use restarts?
|
||||
// 0 = no, 1 = use #moves, 2 = use #plateaus, 3 = use time
|
||||
#define _RESTARTS_ 1
|
||||
// limit of moves/plateaus/seconds until first restart occurs
|
||||
#define _RESTART_LIMIT_ 100
|
||||
// 0 = initialize with all zero, 1 initialize with random value
|
||||
#define _RESTART_INIT_ 0
|
||||
// 0 = even intervals, 1 = pseudo luby, 2 = real luby, 3 = armin, 4 = rapid, 5 = minisat
|
||||
#define _RESTART_SCHEME_ 1
|
||||
// base value c for armin restart scheme using c^inner - only applies for _RESTART_SCHEME_ 3
|
||||
#define _RESTART_CONST_ARMIN_ 2.0
|
||||
|
||||
// timelimit
|
||||
#define _TIMELIMIT_ 3600
|
||||
|
||||
// should score of conjunctions be calculated by average rather than max?
|
||||
#define _SCORE_AND_AVG_ 0
|
||||
|
||||
// should score of discunctions be calculated by multiplication of the inverse score rather than min?
|
||||
#define _SCORE_OR_MUL_ 0
|
||||
|
||||
// do we use some kind of variable neighbourhood-search?
|
||||
// 0 = no, 1 = only consider flipping bits if no better score can be obtained otherwise, 2 = only consider flipping bits until a better score can be obtained
|
||||
#define _VNS_ 0
|
||||
|
||||
// shall we check 2-bit flips in plateaus using Monte Carlo?
|
||||
#define _VNS_MC_ 0
|
||||
|
||||
// how many 2-bit flips shall we try per bit?
|
||||
#define _VNS_MC_TRIES_ 1
|
||||
|
||||
// shall we check another assertion if no improving step was found in the first one?
|
||||
#define _VNS_REPICK_ 0
|
||||
|
||||
// what is the probability of doing so (percentage)?
|
||||
#define _VNS_PERC_ 100
|
||||
|
||||
// do a decreasing move with percentage ...
|
||||
#define _INSIST_PERC_ 0
|
||||
|
||||
// do we reduce the score of unsatisfied literals?
|
||||
// 0 = no
|
||||
// 1 = yes, by multiplying it with some factor
|
||||
// 2 = yes, by squaring it
|
||||
// 3 = yes, by setting it to zero
|
||||
// 4 = by progessively increasing weight (_TIMELIMIT_ needs to be set appropriately!)
|
||||
#define _WEIGHT_DIST_ 1
|
||||
|
||||
// the factor used for _WEIGHT_DIST_ = 1
|
||||
#define _WEIGHT_DIST_FACTOR_ 0.5
|
||||
|
||||
// shall we toggle the weight after each restart?
|
||||
#define _WEIGHT_TOGGLE_ 0
|
||||
|
||||
// do we use intensification steps in local minima? if so, how many?
|
||||
#define _INTENSIFICATION_ 0
|
||||
#define _INTENSIFICATION_TRIES_ 0
|
||||
|
||||
// what is the percentage of random moves in plateaus (instead of full randomization)?
|
||||
#define _PERC_PLATEAU_MOVES_ 0
|
||||
|
||||
// shall we repick assertion when randomizing in a plateau or use the current one?
|
||||
// 0 = use old one, 1 = repick according to usual scheme, 2 = repick randomly and force different one
|
||||
#define _REPICK_ 1
|
||||
|
||||
// do we use some UCT-like scheme for assertion-selection? overrides _BFS_
|
||||
#define _UCT_ 1
|
||||
|
||||
// how much diversification is used in the UCT-scheme?
|
||||
#define _UCT_CONSTANT_ 20.0
|
||||
|
||||
// is uct clause selection probabilistic similar to variable selection in sparrow?
|
||||
// 0 = no, 1 = yes, use uct-value, 2 = yes, use score-value (_UCT_CONSTANT_ = 0.0) with squared score
|
||||
#define _PROBABILISTIC_UCT_ 0
|
||||
|
||||
// additive constants for probabilistic uct > 0
|
||||
#define _UCT_EPS_ 0.0001
|
||||
|
||||
// shall we reset _UCT_ touched values after restart?
|
||||
#define _UCT_RESET_ 0
|
||||
|
||||
// how shall we initialize the _UCT_ total touched counter?
|
||||
// 0 = initialize with one, 1 = initialize with number of assertions
|
||||
#define _UCT_INIT_ 0
|
||||
|
||||
// do we gradually reduce the touched values of _UCT_?
|
||||
#define _UCT_FORGET_ 0
|
||||
#define _UCT_FORGET_FACTOR_ 0.9
|
||||
|
||||
// shall we use addition/subtraction?
|
||||
#define _USE_ADDSUB_ 1
|
||||
|
||||
// shall we try multilication and division by 2?
|
||||
#define _USE_MUL2DIV2_ 0
|
||||
|
||||
// shall we try multiplication by 3?
|
||||
#define _USE_MUL3_ 0
|
||||
|
||||
// shall we try unary minus (= inverting and incrementing)
|
||||
#define _USE_UNARY_MINUS_ 0
|
||||
|
||||
// is random selection for assertions uniform? only works with _BFS_ = _UCT_ = 0
|
||||
#define _UNIFORM_RANDOM_ 0
|
||||
#define _USE_ADDSUB_ 0
|
||||
|
||||
// should we use unsat-structures as done in SLS 4 SAT instead for random or bfs selection?
|
||||
#define _REAL_RS_ 0
|
||||
#define _REAL_PBFS_ 0
|
||||
|
||||
// how many bits do we neglect in each iteration?
|
||||
#define _SKIP_BITS_ 0
|
||||
|
||||
// when randomizing local, what is the probability for changing a single bit?
|
||||
// 0 = use standard scheme and pick a new value at random (= 50), otherwise the value (as int) gives the percentage
|
||||
#define _PERC_CHANGE_ 0
|
||||
|
||||
// do we use random steps for noise?
|
||||
// 0 = no, 1 = randomize local, 2 = make random move
|
||||
#define _TYPE_RSTEP_ 0
|
||||
|
||||
// with what probability _PERM_STEP_/1000 will the random step happen?
|
||||
#define _PERM_RSTEP_ 0
|
||||
|
||||
// shall we use early pruning for incremental update?
|
||||
#define _EARLY_PRUNE_ 1
|
||||
|
||||
// shall we use caching for top_score?
|
||||
#define _CACHE_TOP_SCORE_ 1
|
||||
|
||||
|
||||
#if ((_BFS_ > 0) + (_UCT_ > 0) + _UNIFORM_RANDOM_ + _REAL_RS_ + _REAL_PBFS_ > 1)
|
||||
InvalidConfiguration;
|
||||
#endif
|
||||
#if (_PROBABILISTIC_UCT_ && !_UCT_)
|
||||
InvalidConfiguration;
|
||||
#endif
|
||||
#if (_PERM_RSTEP_ && !_TYPE_RSTEP_)
|
||||
InvalidConfiguration;
|
||||
#endif
|
||||
#if (_PERC_CHANGE_ == 50)
|
||||
InvalidConfiguration;
|
||||
#endif
|
||||
#if (_PERC_STICKY_ && !_FOCUS_)
|
||||
InvalidConfiguration;
|
||||
#endif
|
||||
|
||||
#endif
|
File diff suppressed because it is too large
Load diff
|
@ -22,6 +22,7 @@ Notes:
|
|||
#include"stopwatch.h"
|
||||
#include"lbool.h"
|
||||
#include"model_converter.h"
|
||||
#include"goal.h"
|
||||
|
||||
#include"sls_compilation_settings.h"
|
||||
#include"sls_tracker.h"
|
||||
|
@ -35,17 +36,13 @@ public:
|
|||
stopwatch m_stopwatch;
|
||||
unsigned m_full_evals;
|
||||
unsigned m_incr_evals;
|
||||
unsigned m_moves, m_flips, m_incs, m_decs, m_invs, m_umins, m_mul2s, m_mul3s, m_div2s;
|
||||
unsigned m_moves, m_flips, m_incs, m_decs, m_invs;
|
||||
|
||||
stats() :
|
||||
m_restarts(0),
|
||||
m_full_evals(0),
|
||||
m_incr_evals(0),
|
||||
m_moves(0),
|
||||
m_umins(0),
|
||||
m_mul2s(0),
|
||||
m_mul3s(0),
|
||||
m_div2s(0),
|
||||
m_flips(0),
|
||||
m_incs(0),
|
||||
m_decs(0),
|
||||
|
@ -71,14 +68,22 @@ protected:
|
|||
bv_util m_bv_util;
|
||||
sls_tracker m_tracker;
|
||||
sls_evaluator m_evaluator;
|
||||
ptr_vector<expr> m_assertions;
|
||||
|
||||
unsigned m_restart_limit;
|
||||
unsigned m_max_restarts;
|
||||
unsigned m_plateau_limit;
|
||||
unsigned m_walksat;
|
||||
unsigned m_walksat_repick;
|
||||
unsigned m_wp;
|
||||
unsigned m_vns_mc;
|
||||
unsigned m_vns_repick;
|
||||
unsigned m_paws_sp;
|
||||
unsigned m_restart_base;
|
||||
unsigned m_restart_next;
|
||||
unsigned m_restart_init;
|
||||
|
||||
ptr_vector<mpz> m_old_values;
|
||||
|
||||
typedef enum { MV_FLIP = 0, MV_INC, MV_DEC, MV_INV, MV_UMIN, MV_MUL2, MV_MUL3, MV_DIV2 } move_type;
|
||||
typedef enum { MV_FLIP = 0, MV_INC, MV_DEC, MV_INV } move_type;
|
||||
|
||||
public:
|
||||
sls_engine(ast_manager & m, params_ref const & p);
|
||||
|
@ -92,78 +97,46 @@ public:
|
|||
|
||||
void updt_params(params_ref const & _p);
|
||||
|
||||
void assert_expr(expr * e) { m_assertions.push_back(e); }
|
||||
|
||||
stats const & get_stats(void) { return m_stats; }
|
||||
void reset_statistics(void) { m_stats.reset(); }
|
||||
|
||||
bool full_eval(goal_ref const & g, model & mdl);
|
||||
|
||||
bool full_eval(model & mdl);
|
||||
|
||||
void mk_add(unsigned bv_sz, const mpz & old_value, mpz & add_value, mpz & result);
|
||||
void mk_mul2(unsigned bv_sz, const mpz & old_value, mpz & result);
|
||||
void mk_div2(unsigned bv_sz, const mpz & old_value, mpz & result);
|
||||
void mk_inc(unsigned bv_sz, const mpz & old_value, mpz & incremented);
|
||||
void mk_dec(unsigned bv_sz, const mpz & old_value, mpz & decremented);
|
||||
void mk_inv(unsigned bv_sz, const mpz & old_value, mpz & inverted);
|
||||
void mk_flip(sort * s, const mpz & old_value, unsigned bit, mpz & flipped);
|
||||
void mk_flip(sort * s, const mpz & old_value, unsigned bit, mpz & flipped);
|
||||
|
||||
double find_best_move(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
double find_best_move_lsb(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
double find_best_move_mc(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value);
|
||||
|
||||
double find_best_move_local(expr * e, ptr_vector<func_decl> & to_evaluate,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
|
||||
|
||||
bool what_if(goal_ref const & g, expr * e, func_decl * fd, const mpz & temp,
|
||||
double & best_score, mpz & best_value, unsigned i);
|
||||
|
||||
double find_best_move_local(goal_ref const & g, expr * e, func_decl * fd, mpz & best_value, unsigned i);
|
||||
|
||||
|
||||
lbool search(goal_ref const & g);
|
||||
lbool search(void);
|
||||
|
||||
lbool operator()();
|
||||
void operator()(goal_ref const & g, model_converter_ref & mc);
|
||||
|
||||
protected:
|
||||
void checkpoint();
|
||||
lbool search_old(goal_ref const & g);
|
||||
double get_restart_armin(unsigned cnt_restarts);
|
||||
|
||||
bool what_if(goal_ref const & g, func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
bool what_if(func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
double & best_score, unsigned & best_const, mpz & best_value);
|
||||
|
||||
bool what_if_new(goal_ref const & g, func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
double & best_score, unsigned & best_const, mpz & best_value);
|
||||
double incremental_score_prune_new(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
double top_score();
|
||||
double rescore();
|
||||
double serious_score(func_decl * fd, const mpz & new_value);
|
||||
double incremental_score(func_decl * fd, const mpz & new_value);
|
||||
|
||||
bool what_if_local(expr * e, func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
double & best_score, unsigned & best_const, mpz & best_value);
|
||||
double incremental_score_prune(func_decl * fd, const mpz & new_value);
|
||||
double find_best_move(ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
double top_score(goal_ref const & g);
|
||||
double rescore(goal_ref const & g);
|
||||
double serious_score(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
double incremental_score(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
|
||||
#if _EARLY_PRUNE_
|
||||
double incremental_score_prune(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
#endif
|
||||
|
||||
double find_best_move_vns(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
double find_best_move_mc(ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value);
|
||||
|
||||
void mk_random_move(ptr_vector<func_decl> & unsat_constants);
|
||||
void mk_random_move(goal_ref const & g);
|
||||
|
||||
bool handle_plateau(goal_ref const & g);
|
||||
bool handle_plateau(goal_ref const & g, double old_score);
|
||||
|
||||
//inline double get_restart_armin(unsigned cnt_restarts);
|
||||
inline unsigned check_restart(unsigned curr_value);
|
||||
};
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
@ -81,11 +81,7 @@ public:
|
|||
case OP_AND: {
|
||||
m_mpz_manager.set(result, m_one);
|
||||
for (unsigned i = 0; i < n_args; i++)
|
||||
#if _DIRTY_UP_
|
||||
if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result) && !m_tracker.is_top_expr(args[i])) {
|
||||
#else
|
||||
if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result)) {
|
||||
#endif
|
||||
m_mpz_manager.set(result, m_zero);
|
||||
break;
|
||||
}
|
||||
|
@ -93,11 +89,7 @@ public:
|
|||
}
|
||||
case OP_OR: {
|
||||
for (unsigned i = 0; i < n_args; i++)
|
||||
#if _DIRTY_UP_
|
||||
if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result) || m_tracker.is_top_expr(args[i])) {
|
||||
#else
|
||||
if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result)) {
|
||||
#endif
|
||||
m_mpz_manager.set(result, m_one);
|
||||
break;
|
||||
}
|
||||
|
@ -105,16 +97,9 @@ public:
|
|||
}
|
||||
case OP_NOT: {
|
||||
SASSERT(n_args == 1);
|
||||
#if _DIRTY_UP_
|
||||
if (m_tracker.is_top_expr(args[0]))
|
||||
m_mpz_manager.set(result, m_zero);
|
||||
else
|
||||
m_mpz_manager.set(result, (m_mpz_manager.is_zero(m_tracker.get_value(args[0]))) ? m_one : m_zero);
|
||||
#else
|
||||
const mpz & child = m_tracker.get_value(args[0]);
|
||||
SASSERT(m_mpz_manager.is_one(child) || m_mpz_manager.is_zero(child));
|
||||
m_mpz_manager.set(result, (m_mpz_manager.is_zero(child)) ? m_one : m_zero);
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
case OP_EQ: {
|
||||
|
@ -545,9 +530,7 @@ public:
|
|||
expr_fast_mark1 visited;
|
||||
mpz new_value;
|
||||
|
||||
#if _EARLY_PRUNE_ || _CACHE_TOP_SCORE_
|
||||
double new_score;
|
||||
#endif
|
||||
|
||||
SASSERT(cur_depth < m_traversal_stack.size());
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
|
@ -559,8 +542,7 @@ public:
|
|||
(*this)(to_app(cur), new_value);
|
||||
m_tracker.set_value(cur, new_value);
|
||||
|
||||
#if _REAL_RS_ || _REAL_PBFS_
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
#if _REAL_RS_
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
{
|
||||
if (m_mpz_manager.eq(new_value,m_one))
|
||||
|
@ -570,25 +552,12 @@ public:
|
|||
}
|
||||
#endif
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#if _EARLY_PRUNE_
|
||||
new_score = m_tracker.score(cur);
|
||||
#if _CACHE_TOP_SCORE_
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
#endif
|
||||
m_tracker.set_score(cur, new_score);
|
||||
m_tracker.set_score_prune(cur, new_score);
|
||||
#else
|
||||
#if _CACHE_TOP_SCORE_
|
||||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#else
|
||||
m_tracker.set_score(cur, m_tracker.score(cur));
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
|
@ -617,9 +586,7 @@ public:
|
|||
expr_fast_mark1 visited;
|
||||
mpz new_value;
|
||||
|
||||
#if _EARLY_PRUNE_ || _CACHE_TOP_SCORE_
|
||||
double new_score;
|
||||
#endif
|
||||
|
||||
SASSERT(cur_depth < m_traversal_stack.size());
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
|
@ -630,25 +597,12 @@ public:
|
|||
|
||||
(*this)(to_app(cur), new_value);
|
||||
m_tracker.set_value(cur, new_value);
|
||||
new_score = m_tracker.score(cur);
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#if _EARLY_PRUNE_
|
||||
new_score = m_tracker.score(cur);
|
||||
#if _CACHE_TOP_SCORE_
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
#endif
|
||||
m_tracker.set_score(cur, new_score);
|
||||
m_tracker.set_score_prune(cur, new_score);
|
||||
#else
|
||||
#if _CACHE_TOP_SCORE_
|
||||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#else
|
||||
m_tracker.set_score(cur, m_tracker.score(cur));
|
||||
#endif
|
||||
#endif
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
|
@ -684,11 +638,7 @@ public:
|
|||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
if (cur_depth > max_depth) max_depth = cur_depth;
|
||||
}
|
||||
#if _REAL_RS_ || _REAL_PBFS_ || _PAWS_
|
||||
run_serious_update(max_depth);
|
||||
#else
|
||||
run_update(max_depth);
|
||||
#endif
|
||||
}
|
||||
|
||||
void update(func_decl * fd, const mpz & new_value) {
|
||||
|
@ -713,7 +663,6 @@ public:
|
|||
run_serious_update(cur_depth);
|
||||
}
|
||||
|
||||
#if _EARLY_PRUNE_
|
||||
unsigned run_update_bool_prune(unsigned cur_depth) {
|
||||
expr_fast_mark1 visited;
|
||||
|
||||
|
@ -727,19 +676,15 @@ public:
|
|||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
#if _CACHE_TOP_SCORE_
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
#endif
|
||||
|
||||
prune_score = m_tracker.get_score_prune(cur);
|
||||
m_tracker.set_score(cur, new_score);
|
||||
|
||||
if ((new_score > prune_score) && (m_tracker.has_pos_occ(cur)))
|
||||
//if ((new_score >= prune_score) && (m_tracker.has_pos_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
if ((new_score <= prune_score) && (m_tracker.has_neg_occ(cur)))
|
||||
//if ((new_score < prune_score) && (m_tracker.has_neg_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
|
@ -754,9 +699,6 @@ public:
|
|||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
cur_depth_exprs.reset();
|
||||
|
@ -770,15 +712,11 @@ public:
|
|||
for (unsigned i = 0; i < cur_size; i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
#if _CACHE_TOP_SCORE_
|
||||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#else
|
||||
m_tracker.set_score(cur, m_tracker.score(cur));
|
||||
#endif
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
|
@ -859,161 +797,18 @@ public:
|
|||
}
|
||||
return run_update_bool_prune(cur_depth);
|
||||
}
|
||||
#endif
|
||||
|
||||
unsigned run_update_bool_prune_new(unsigned cur_depth) {
|
||||
expr_fast_mark1 visited;
|
||||
|
||||
double prune_score, new_score;
|
||||
unsigned pot_benefits = 0;
|
||||
SASSERT(cur_depth < m_traversal_stack_bool.size());
|
||||
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack_bool[cur_depth];
|
||||
|
||||
for (unsigned i = 0; i < cur_depth_exprs.size(); i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
prune_score = m_tracker.get_score_prune(cur);
|
||||
m_tracker.set_score(cur, new_score);
|
||||
|
||||
if ((new_score >= prune_score) && (m_tracker.has_pos_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
if ((new_score < prune_score) && (m_tracker.has_neg_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack_bool[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack_bool[cur_depth];
|
||||
if (pot_benefits)
|
||||
{
|
||||
unsigned cur_size = cur_depth_exprs.size();
|
||||
for (unsigned i = 0; i < cur_size; i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack_bool[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
}
|
||||
|
||||
return pot_benefits;
|
||||
}
|
||||
|
||||
unsigned update_prune_new(func_decl * fd, const mpz & new_value) {
|
||||
m_tracker.set_value(fd, new_value);
|
||||
expr * ep = m_tracker.get_entry_point(fd);
|
||||
unsigned cur_depth = m_tracker.get_distance(ep);
|
||||
|
||||
if (m_traversal_stack_bool.size() <= cur_depth)
|
||||
m_traversal_stack_bool.resize(cur_depth+1);
|
||||
if (m_traversal_stack.size() <= cur_depth)
|
||||
m_traversal_stack.resize(cur_depth+1);
|
||||
|
||||
if (m_manager.is_bool(ep))
|
||||
m_traversal_stack_bool[cur_depth].push_back(ep);
|
||||
else
|
||||
{
|
||||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
run_update_prune(cur_depth);
|
||||
}
|
||||
return run_update_bool_prune_new(cur_depth);
|
||||
}
|
||||
|
||||
void randomize_local(ptr_vector<func_decl> & unsat_constants) {
|
||||
// Randomize _all_ candidates:
|
||||
|
||||
//// bool did_something = false;
|
||||
//for (unsigned i = 0; i < unsat_constants.size(); i++) {
|
||||
// func_decl * fd = unsat_constants[i];
|
||||
// mpz temp = m_tracker.get_random(fd->get_range());
|
||||
// // if (m_mpz_manager.neq(temp, m_tracker.get_value(fd))) {
|
||||
// // did_something = true;
|
||||
// // }
|
||||
// update(fd, temp);
|
||||
// m_mpz_manager.del(temp);
|
||||
//}
|
||||
|
||||
// Randomize _one_ candidate:
|
||||
unsigned r = m_tracker.get_random_uint(16) % unsat_constants.size();
|
||||
func_decl * fd = unsat_constants[r];
|
||||
#if _PERC_CHANGE_
|
||||
sort * srt = fd->get_range();
|
||||
mpz temp;
|
||||
|
||||
if (m_manager.is_bool(srt))
|
||||
m_mpz_manager.set(temp, (m_mpz_manager.is_zero(m_tracker.get_value(fd))) ? m_one : m_zero);
|
||||
else
|
||||
{
|
||||
mpz temp2, mask;
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(srt);
|
||||
m_mpz_manager.set(temp, m_tracker.get_value(fd));
|
||||
|
||||
for (unsigned bit = 0; bit < bv_sz; bit++)
|
||||
if (m_tracker.get_random_uint(16) % 100 < _PERC_CHANGE_)
|
||||
{
|
||||
m_mpz_manager.set(mask, m_powers(bit));
|
||||
m_mpz_manager.bitwise_xor(temp, mask, temp2);
|
||||
m_mpz_manager.set(temp, temp2);
|
||||
}
|
||||
m_mpz_manager.del(mask);
|
||||
m_mpz_manager.del(temp2);
|
||||
}
|
||||
#else
|
||||
mpz temp = m_tracker.get_random(fd->get_range());
|
||||
#endif
|
||||
|
||||
#if _REAL_RS_ || _REAL_PBFS_ || _PAWS_
|
||||
serious_update(fd, temp);
|
||||
#else
|
||||
update(fd, temp);
|
||||
#endif
|
||||
|
||||
m_mpz_manager.del(temp);
|
||||
|
||||
TRACE("sls", /*tout << "Randomization candidates: ";
|
||||
for (unsigned i = 0; i < unsat_constants.size(); i++)
|
||||
tout << unsat_constants[i]->get_name() << ", ";
|
||||
tout << std::endl;*/
|
||||
tout << "Randomization candidate: " << unsat_constants[r]->get_name() << std::endl;
|
||||
TRACE("sls", tout << "Randomization candidate: " << unsat_constants[r]->get_name() << std::endl;
|
||||
tout << "Locally randomized model: " << std::endl;
|
||||
m_tracker.show_model(tout); );
|
||||
|
||||
|
@ -1023,36 +818,9 @@ public:
|
|||
randomize_local(m_tracker.get_constants(e));
|
||||
}
|
||||
|
||||
void randomize_local(goal_ref const & g, unsigned int flip) {
|
||||
randomize_local(m_tracker.get_unsat_constants(g, flip));
|
||||
void randomize_local(ptr_vector<expr> const & as) {
|
||||
randomize_local(m_tracker.get_unsat_constants(as));
|
||||
}
|
||||
|
||||
void randomize_local_n(goal_ref const & g, ptr_vector<func_decl> & unsat_constants) {
|
||||
unsigned r = m_tracker.get_random_uint(16) % unsat_constants.size();
|
||||
func_decl * fd = unsat_constants[r];
|
||||
sort * srt = fd->get_range();
|
||||
unsigned bv_sz = m_manager.is_bool(srt) ? 1 : m_bv_util.get_bv_size(srt);
|
||||
mpz max_val = m_tracker.get_random(srt);
|
||||
update(fd, max_val);
|
||||
double max_score = m_tracker.get_top_sum() / g->size();
|
||||
mpz temp_val;
|
||||
double temp_score;
|
||||
for (unsigned i = 1; i < 2; i++)
|
||||
//for (unsigned i = 1; i < bv_sz; i++)
|
||||
{
|
||||
m_mpz_manager.set(temp_val, m_tracker.get_random(srt));
|
||||
update(fd, temp_val);
|
||||
temp_score = m_tracker.get_top_sum() / g->size();
|
||||
if (temp_score > max_score)
|
||||
{
|
||||
m_mpz_manager.set(max_val, temp_val);
|
||||
max_score = temp_score;
|
||||
}
|
||||
}
|
||||
update(fd, max_val);
|
||||
m_mpz_manager.del(temp_val);
|
||||
m_mpz_manager.del(max_val);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
|
@ -1507,16 +1507,12 @@ tactic * mk_preamble(ast_manager & m, params_ref const & p) {
|
|||
using_params(mk_simplify_tactic(m), simp2_p)),
|
||||
using_params(mk_simplify_tactic(m), hoist_p),
|
||||
mk_max_bv_sharing_tactic(m),
|
||||
// Andreas: It would be cool to get rid of shared top level assertions but which simplification is doing this?
|
||||
//mk_ctx_simplify_tactic(m, ctx_p),
|
||||
// Andreas: This one at least eliminates top level duplicates ... but has very bad effects on performance!
|
||||
//mk_simplify_tactic(m),
|
||||
mk_nnf_tactic(m, p));
|
||||
}
|
||||
|
||||
tactic * mk_qfbv_sls_tactic(ast_manager & m, params_ref const & p) {
|
||||
tactic * t = and_then(mk_preamble(m, p), mk_sls_tactic(m));
|
||||
// tactic * t = and_then(mk_simplify_tactic(m), mk_nnf_tactic(m, p), mk_sls_tactic(m));
|
||||
//tactic * t = and_then(mk_simplify_tactic(m), mk_nnf_tactic(m, p), mk_sls_tactic(m));
|
||||
t->updt_params(p);
|
||||
return t;
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue