mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 09:05:31 +00:00
Code Activity

saved params work

Browse source 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura 2012-11-29 17:19:12 -08:00
parent c3055207ed
commit cf28cbab0a
130 changed files with 1469 additions and 948 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/sat/sat_asymm_branch.cpp
View file

@ -194,17 +194,17 @@ namespace sat {
}
void asymm_branch::updt_params(params_ref const & p) {
m_asymm_branch = p.get_bool(":asymm-branch", true);
m_asymm_branch_rounds = p.get_uint(":asymm-branch-rounds", 32);
m_asymm_branch_limit = p.get_uint(":asymm-branch-limit", 100000000);
m_asymm_branch = p.get_bool("asymm_branch", true);
m_asymm_branch_rounds = p.get_uint("asymm_branch_rounds", 32);
m_asymm_branch_limit = p.get_uint("asymm_branch_limit", 100000000);
if (m_asymm_branch_limit > INT_MAX)
m_asymm_branch_limit = INT_MAX;
}
void asymm_branch::collect_param_descrs(param_descrs & d) {
d.insert(":asymm-branch", CPK_BOOL, "(default: true) asymmetric branching.");
d.insert(":asymm-branch-rounds", CPK_UINT, "(default: 32) maximum number of rounds of asymmetric branching.");
d.insert(":asymm-branch-limit", CPK_UINT, "approx. maximum number of literals visited during asymmetric branching.");
d.insert("asymm_branch", CPK_BOOL, "(default: true) asymmetric branching.");
d.insert("asymm_branch_rounds", CPK_UINT, "(default: 32) maximum number of rounds of asymmetric branching.");
d.insert("asymm_branch_limit", CPK_UINT, "approx. maximum number of literals visited during asymmetric branching.");
}
void asymm_branch::collect_statistics(statistics & st) {

86
src/sat/sat_config.cpp
View file

@ -22,24 +22,24 @@ Revision History:
namespace sat {
config::config(params_ref const & p):
m_always_true("always-true"),
m_always_false("always-false"),
m_always_true("always_true"),
m_always_false("always_false"),
m_caching("caching"),
m_random("random"),
m_geometric("geometric"),
m_luby("luby"),
m_dyn_psm("dyn-psm"),
m_dyn_psm("dyn_psm"),
m_psm("psm"),
m_glue("glue"),
m_glue_psm("glue-psm"),
m_psm_glue("psm-glue") {
m_glue_psm("glue_psm"),
m_psm_glue("psm_glue") {
updt_params(p);
}
void config::updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
symbol s = p.get_sym(":restart", m_luby);
symbol s = p.get_sym("restart", m_luby);
if (s == m_luby)
m_restart = RS_LUBY;
else if (s == m_geometric)
@ -47,7 +47,7 @@ namespace sat {
else
throw sat_param_exception("invalid restart strategy");
s = p.get_sym(":phase", m_caching);
s = p.get_sym("phase", m_caching);
if (s == m_always_false)
m_phase = PS_ALWAYS_FALSE;
else if (s == m_always_true)
@ -59,29 +59,29 @@ namespace sat {
else
throw sat_param_exception("invalid phase selection strategy");
m_phase_caching_on = p.get_uint(":phase-caching-on", 400);
m_phase_caching_off = p.get_uint(":phase-caching-off", 100);
m_phase_caching_on = p.get_uint("phase_caching_on", 400);
m_phase_caching_off = p.get_uint("phase_caching_off", 100);
m_restart_initial = p.get_uint(":restart-initial", 100);
m_restart_factor = p.get_double(":restart-factor", 1.5);
m_restart_initial = p.get_uint("restart_initial", 100);
m_restart_factor = p.get_double("restart_factor", 1.5);
m_random_freq = p.get_double(":random-freq", 0.01);
m_random_freq = p.get_double("random_freq", 0.01);
m_burst_search = p.get_uint(":burst-search", 100);
m_burst_search = p.get_uint("burst_search", 100);
m_max_conflicts = p.get_uint(":max-conflicts", UINT_MAX);
m_max_conflicts = p.get_uint("max_conflicts", UINT_MAX);
m_simplify_mult1 = p.get_uint(":simplify-mult1", 300);
m_simplify_mult2 = p.get_double(":simplify-mult2", 1.5);
m_simplify_max = p.get_uint(":simplify-max", 500000);
m_simplify_mult1 = p.get_uint("simplify_mult1", 300);
m_simplify_mult2 = p.get_double("simplify_mult2", 1.5);
m_simplify_max = p.get_uint("simplify_max", 500000);
s = p.get_sym(":gc-strategy", m_glue_psm);
s = p.get_sym("gc_strategy", m_glue_psm);
if (s == m_dyn_psm) {
m_gc_strategy = GC_DYN_PSM;
m_gc_initial = p.get_uint(":gc-initial", 500);
m_gc_increment = p.get_uint(":gc-increment", 100);
m_gc_small_lbd = p.get_uint(":gc-small-lbd", 3);
m_gc_k = p.get_uint(":gc-k", 7);
m_gc_initial = p.get_uint("gc_initial", 500);
m_gc_increment = p.get_uint("gc_increment", 100);
m_gc_small_lbd = p.get_uint("gc_small_lbd", 3);
m_gc_k = p.get_uint("gc_k", 7);
if (m_gc_k > 255)
m_gc_k = 255;
}
@ -96,31 +96,31 @@ namespace sat {
m_gc_strategy = GC_PSM_GLUE;
else
throw sat_param_exception("invalid gc strategy");
m_gc_initial = p.get_uint(":gc-initial", 20000);
m_gc_increment = p.get_uint(":gc-increment", 500);
m_gc_initial = p.get_uint("gc_initial", 20000);
m_gc_increment = p.get_uint("gc_increment", 500);
}
m_minimize_lemmas = p.get_bool(":minimize-lemmas", true);
m_dyn_sub_res = p.get_bool(":dyn-sub-res", true);
m_minimize_lemmas = p.get_bool("minimize_lemmas", true);
m_dyn_sub_res = p.get_bool("dyn_sub_res", true);
}
void config::collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
r.insert(":phase", CPK_SYMBOL, "(default: caching) phase selection strategy: always-false, always-true, caching, random.");
r.insert(":phase-caching-on", CPK_UINT, "(default: 400)");
r.insert(":phase-caching-off", CPK_UINT, "(default: 100)");
r.insert(":restart", CPK_SYMBOL, "(default: luby) restart strategy: luby or geometric.");
r.insert(":restart-initial", CPK_UINT, "(default: 100) initial restart (number of conflicts).");
r.insert(":restart-factor", CPK_DOUBLE, "(default: 1.5) restart increment factor for geometric strategy.");
r.insert(":random-freq", CPK_DOUBLE, "(default: 0.01) frequency of random case splits.");
r.insert(":burst-search", CPK_UINT, "(default: 100) number of conflicts before first global simplification.");
r.insert(":max-conflicts", CPK_UINT, "(default: inf) maximum number of conflicts.");
r.insert(":gc-strategy", CPK_SYMBOL, "(default: glue-psm) garbage collection strategy: psm, glue, glue-psm, dyn-psm.");
r.insert(":gc-initial", CPK_UINT, "(default: 20000) learned clauses garbage collection frequence.");
r.insert(":gc-increment", CPK_UINT, "(default: 500) increment to the garbage collection threshold.");
r.insert(":gc-small-lbd", CPK_UINT, "(default: 3) learned clauses with small LBD are never deleted (only used in dyn-psm).");
r.insert(":gc-k", CPK_UINT, "(default: 7) learned clauses that are inactive for k gc rounds are permanently deleted (only used in dyn-psm).");
r.insert(":minimize-lemmas", CPK_BOOL, "(default: true) minimize learned clauses.");
r.insert(":dyn-sub-res", CPK_BOOL, "(default: true) dynamic subsumption resolution for minimizing learned clauses.");
r.insert("phase", CPK_SYMBOL, "(default: caching) phase selection strategy: always_false, always_true, caching, random.");
r.insert("phase_caching_on", CPK_UINT, "(default: 400)");
r.insert("phase_caching_off", CPK_UINT, "(default: 100)");
r.insert("restart", CPK_SYMBOL, "(default: luby) restart strategy: luby or geometric.");
r.insert("restart_initial", CPK_UINT, "(default: 100) initial restart (number of conflicts).");
r.insert("restart_factor", CPK_DOUBLE, "(default: 1.5) restart increment factor for geometric strategy.");
r.insert("random_freq", CPK_DOUBLE, "(default: 0.01) frequency of random case splits.");
r.insert("burst_search", CPK_UINT, "(default: 100) number of conflicts before first global simplification.");
r.insert("max_conflicts", CPK_UINT, "(default: inf) maximum number of conflicts.");
r.insert("gc_strategy", CPK_SYMBOL, "(default: glue_psm) garbage collection strategy: psm, glue, glue_psm, dyn_psm.");
r.insert("gc_initial", CPK_UINT, "(default: 20000) learned clauses garbage collection frequence.");
r.insert("gc_increment", CPK_UINT, "(default: 500) increment to the garbage collection threshold.");
r.insert("gc_small_lbd", CPK_UINT, "(default: 3) learned clauses with small LBD are never deleted (only used in dyn_psm).");
r.insert("gc_k", CPK_UINT, "(default: 7) learned clauses that are inactive for k gc rounds are permanently deleted (only used in dyn_psm).");
r.insert("minimize_lemmas", CPK_BOOL, "(default: true) minimize learned clauses.");
r.insert("dyn_sub_res", CPK_BOOL, "(default: true) dynamic subsumption resolution for minimizing learned clauses.");
}
};

10
src/sat/sat_probing.cpp
View file

@ -243,11 +243,11 @@ namespace sat {
}
void probing::updt_params(params_ref const & p) {
m_probing = p.get_bool(":probing", true);
m_probing_limit = p.get_uint(":probing-limit", 5000000);
m_probing_cache = p.get_bool(":probing-cache", true);
m_probing_binary = p.get_bool(":probing-binary", true);
m_probing_cache_limit = megabytes_to_bytes(p.get_uint(":probing-chache-limit", 1024));
m_probing = p.get_bool("probing", true);
m_probing_limit = p.get_uint("probing_limit", 5000000);
m_probing_cache = p.get_bool("probing_cache", true);
m_probing_binary = p.get_bool("probing_binary", true);
m_probing_cache_limit = megabytes_to_bytes(p.get_uint("probing_chache_limit", 1024));
}
void probing::collect_param_descrs(param_descrs & d) {

4
src/sat/sat_scc.cpp
View file

@ -231,11 +231,11 @@ namespace sat {
}
void scc::updt_params(params_ref const & p) {
m_scc = p.get_bool(":scc", true);
m_scc = p.get_bool("scc", true);
}
void scc::collect_param_descrs(param_descrs & d) {
d.insert(":scc", CPK_BOOL, "(default: true) eliminate Boolean variables by computing strongly connected components.");
d.insert("scc", CPK_BOOL, "(default: true) eliminate Boolean variables by computing strongly connected components.");
}
};

64
src/sat/sat_simplifier.cpp
View file

@ -1431,44 +1431,44 @@ namespace sat {
}
void simplifier::updt_params(params_ref const & p) {
m_elim_blocked_clauses = p.get_bool(":elim-blocked-clauses", false);
m_elim_blocked_clauses_at = p.get_uint(":elim-blocked-clauses-at", 2);
m_blocked_clause_limit = p.get_uint(":blocked-clause-limit", 100000000);
m_resolution = p.get_bool(":resolution", true);
m_res_limit = p.get_uint(":resolution-limit", 500000000);
m_res_occ_cutoff = p.get_uint(":res-occ-cutoff", 10);
m_res_occ_cutoff1 = p.get_uint(":res-occ-cutoff-range1", 8);
m_res_occ_cutoff2 = p.get_uint(":res-occ-cutoff-range2", 5);
m_res_occ_cutoff3 = p.get_uint(":res-occ-cutoff-range3", 3);
m_res_lit_cutoff1 = p.get_uint(":res-lit-cutoff-range1", 700);
m_res_lit_cutoff2 = p.get_uint(":res-lit-cutoff-range2", 400);
m_res_lit_cutoff3 = p.get_uint(":res-lit-cutoff-range3", 300);
m_res_cls_cutoff1 = p.get_uint(":res-cls-cutoff1", 100000);
m_res_cls_cutoff2 = p.get_uint(":res-cls-cutoff2", 700000);
m_subsumption = p.get_bool(":subsumption", true);
m_subsumption_limit = p.get_uint(":subsumption-limit", 100000000);
m_elim_blocked_clauses = p.get_bool("elim_blocked_clauses", false);
m_elim_blocked_clauses_at = p.get_uint("elim_blocked_clauses_at", 2);
m_blocked_clause_limit = p.get_uint("blocked_clause_limit", 100000000);
m_resolution = p.get_bool("resolution", true);
m_res_limit = p.get_uint("resolution_limit", 500000000);
m_res_occ_cutoff = p.get_uint("res_occ_cutoff", 10);
m_res_occ_cutoff1 = p.get_uint("res_occ_cutoff_range1", 8);
m_res_occ_cutoff2 = p.get_uint("res_occ_cutoff_range2", 5);
m_res_occ_cutoff3 = p.get_uint("res_occ_cutoff_range3", 3);
m_res_lit_cutoff1 = p.get_uint("res_lit_cutoff_range1", 700);
m_res_lit_cutoff2 = p.get_uint("res_lit_cutoff_range2", 400);
m_res_lit_cutoff3 = p.get_uint("res_lit_cutoff_range3", 300);
m_res_cls_cutoff1 = p.get_uint("res_cls_cutoff1", 100000);
m_res_cls_cutoff2 = p.get_uint("res_cls_cutoff2", 700000);
m_subsumption = p.get_bool("subsumption", true);
m_subsumption_limit = p.get_uint("subsumption_limit", 100000000);
}
void simplifier::collect_param_descrs(param_descrs & r) {
r.insert(":elim-blocked-clauses", CPK_BOOL, "(default: false) eliminate blocked clauses.");
r.insert(":elim-blocked-clauses-at", CPK_UINT, "(default: 2) eliminate blocked clauses only once at the given simplification round.");
r.insert(":blocked-clause-limit", CPK_UINT, "(default: 100000000) maximum number of literals visited during blocked clause elimination.");
r.insert(":resolution", CPK_BOOL, "(default: true) eliminate boolean variables using resolution.");
r.insert(":resolution-limit", CPK_UINT, "(default: 500000000) approx. maximum number of literals visited during variable elimination.");
r.insert(":res-occ-cutoff", CPK_UINT, "(default: 10) first cutoff (on number of positive/negative occurrences) for Boolean variable elimination.");
r.insert(":res-occ-cutoff-range1", CPK_UINT, "(default: 8) second cutoff (number of positive/negative occurrences) for Boolean variable elimination, for problems containing less than :res-cls-cutoff1 clauses.");
r.insert(":res-occ-cutoff-range2", CPK_UINT, "(default: 5) second cutoff (number of positive/negative occurrences) for Boolean variable elimination, for problems containing more than :res-cls-cutoff1 and less than :res-cls-cutoff2.");
r.insert(":res-occ-cutoff-range3", CPK_UINT, "(default: 3) second cutoff (number of positive/negative occurrences) for Boolean variable elimination, for problems containing more than :res-cls-cutoff2.");
r.insert("elim_blocked_clauses", CPK_BOOL, "(default: false) eliminate blocked clauses.");
r.insert("elim_blocked_clauses_at", CPK_UINT, "(default: 2) eliminate blocked clauses only once at the given simplification round.");
r.insert("blocked_clause_limit", CPK_UINT, "(default: 100000000) maximum number of literals visited during blocked clause elimination.");
r.insert("resolution", CPK_BOOL, "(default: true) eliminate boolean variables using resolution.");
r.insert("resolution_limit", CPK_UINT, "(default: 500000000) approx. maximum number of literals visited during variable elimination.");
r.insert("res_occ_cutoff", CPK_UINT, "(default: 10) first cutoff (on number of positive/negative occurrences) for Boolean variable elimination.");
r.insert("res_occ_cutoff_range1", CPK_UINT, "(default: 8) second cutoff (number of positive/negative occurrences) for Boolean variable elimination, for problems containing less than res_cls_cutoff1 clauses.");
r.insert("res_occ_cutoff_range2", CPK_UINT, "(default: 5) second cutoff (number of positive/negative occurrences) for Boolean variable elimination, for problems containing more than res_cls_cutoff1 and less than res_cls_cutoff2.");
r.insert("res_occ_cutoff_range3", CPK_UINT, "(default: 3) second cutoff (number of positive/negative occurrences) for Boolean variable elimination, for problems containing more than res_cls_cutoff2.");
r.insert(":res-lit-cutoff-range1", CPK_UINT, "(default: 700) second cutoff (total number of literals) for Boolean variable elimination, for problems containing less than :res-cls-cutoff1 clauses.");
r.insert(":res-lit-cutoff-range2", CPK_UINT, "(default: 400) second cutoff (total number of literals) for Boolean variable elimination, for problems containing more than :res-cls-cutoff1 and less than :res-cls-cutoff2.");
r.insert(":res-lit-cutoff-range3", CPK_UINT, "(default: 300) second cutoff (total number of literals) for Boolean variable elimination, for problems containing more than :res-cls-cutoff2.");
r.insert("res_lit_cutoff_range1", CPK_UINT, "(default: 700) second cutoff (total number of literals) for Boolean variable elimination, for problems containing less than res_cls_cutoff1 clauses.");
r.insert("res_lit_cutoff_range2", CPK_UINT, "(default: 400) second cutoff (total number of literals) for Boolean variable elimination, for problems containing more than res_cls_cutoff1 and less than res_cls_cutoff2.");
r.insert("res_lit_cutoff_range3", CPK_UINT, "(default: 300) second cutoff (total number of literals) for Boolean variable elimination, for problems containing more than res_cls_cutoff2.");
r.insert(":res-cls-cutoff1", CPK_UINT, "(default: 100000000) limit1 - total number of problems clauses for the second cutoff of Boolean variable elimination.");
r.insert(":res-cls-cutoff2", CPK_UINT, "(default: 700000000) limit2 - total number of problems clauses for the second cutoff of Boolean variable elimination.");
r.insert("res_cls_cutoff1", CPK_UINT, "(default: 100000000) limit1 - total number of problems clauses for the second cutoff of Boolean variable elimination.");
r.insert("res_cls_cutoff2", CPK_UINT, "(default: 700000000) limit2 - total number of problems clauses for the second cutoff of Boolean variable elimination.");
r.insert(":subsumption", CPK_BOOL, "(default: true) eliminate subsumed clauses.");
r.insert(":subsumption-limit", CPK_UINT, "(default: 100000000) approx. maximum number of literals visited during subsumption (and subsumption resolution).");
r.insert("subsumption", CPK_BOOL, "(default: true) eliminate subsumed clauses.");
r.insert("subsumption_limit", CPK_UINT, "(default: 100000000) approx. maximum number of literals visited during subsumption (and subsumption resolution).");
}
void simplifier::collect_statistics(statistics & st) {

2
src/sat/sat_solver.cpp
View file

@ -1909,7 +1909,7 @@ namespace sat {
m_asymm_branch.updt_params(p);
m_probing.updt_params(p);
m_scc.updt_params(p);
m_rand.set_seed(p.get_uint(":random-seed", 0));
m_rand.set_seed(p.get_uint("random_seed", 0));
}
void solver::collect_param_descrs(param_descrs & d) {

12
src/sat/tactic/goal2sat.cpp
View file

@ -67,8 +67,8 @@ struct goal2sat::imp {
}
void updt_params(params_ref const & p) {
m_ite_extra = p.get_bool(":ite-extra", true);
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_ite_extra = p.get_bool("ite_extra", true);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
}
void throw_op_not_handled() {
@ -420,7 +420,7 @@ goal2sat::goal2sat():m_imp(0) {
void goal2sat::collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
r.insert(":ite-extra", CPK_BOOL, "(default: true) add redundant clauses (that improve unit propagation) when encoding if-then-else formulas");
r.insert("ite_extra", CPK_BOOL, "(default: true) add redundant clauses (that improve unit propagation) when encoding if-then-else formulas");
}
struct goal2sat::scoped_set_imp {
@ -575,8 +575,8 @@ struct sat2goal::imp {
}
void updt_params(params_ref const & p) {
m_learned = p.get_bool(":learned", false);
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_learned = p.get_bool("learned", false);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
}
void checkpoint() {
@ -676,7 +676,7 @@ sat2goal::sat2goal():m_imp(0) {
void sat2goal::collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
r.insert(":learned", CPK_BOOL, "(default: false) collect also learned clauses.");
r.insert("learned", CPK_BOOL, "(default: false) collect also learned clauses.");
}
struct sat2goal::scoped_set_imp {

2
src/sat/tactic/sat_tactic.cpp
View file

@ -210,7 +210,7 @@ tactic * mk_sat_tactic(ast_manager & m, params_ref const & p) {
tactic * mk_sat_preprocessor_tactic(ast_manager & m, params_ref const & p) {
params_ref p_aux;
p_aux.set_uint(":max-conflicts", 0);
p_aux.set_uint("max_conflicts", 0);
tactic * t = clean(using_params(mk_sat_tactic(m, p), p_aux));
t->updt_params(p);
return t;