mirror of
https://github.com/Z3Prover/z3
synced 2026-03-23 12:59:12 +00:00
Setting up param tuning infrastructure in C++ (#8006)
* draft attempt at optimizing cube tree with resolvents. have not tested/ran yet
* adding comments
* fix bug about needing to bubble resolvent upwards to highest ancestor
* fix bug where we need to cover the whole resolvent in the path when bubbling up
* clean up comments
* Bump actions/checkout from 4 to 5 (#7954)
Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 5.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4...v5)
---
updated-dependencies:
- dependency-name: actions/checkout
dependency-version: '5'
dependency-type: direct:production
update-type: version-update:semver-major
...
Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
* close entire tree when sibling resolvent is empty
* integrate asms directly into cube tree, remove separate tracking
* try to fix bug about redundant resolutions, merging close and try_resolve_upwards into once function
* separate the logic again to avoid mutual recursion
* [WIP] Add a mutex to warning.cpp to ensure that warning messages from different threads don't interfere (#7963)
* Initial plan
* Add mutex to warning.cpp for thread safety
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
---------
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Remove unused variable 'first' in mpz.cpp
Removed unused variable 'first' from the function.
* fixing the order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* fixing the order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* fix the order of parameter evaluation
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* remove AI slop
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
* param order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* param order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* param order evaluation
* parameter eval order
* parameter evaluation order
* param eval
* param eval order
* parameter eval order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* parameter eval order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* parameter eval order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* parameter eval order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* parameter eval order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* parameter eval order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* parameter eval order
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* Bump github/codeql-action from 3 to 4 (#7971)
Bumps [github/codeql-action](https://github.com/github/codeql-action) from 3 to 4.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/v3...v4)
---
updated-dependencies:
- dependency-name: github/codeql-action
dependency-version: '4'
dependency-type: direct:production
update-type: version-update:semver-major
...
Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
* Update Z3_mk_datatype_sort API to accept array of sort parameters and add Z3_mk_polymorphic_datatype (#7966)
* Initial plan
* Update Z3_mk_datatype_sort API to accept array of parameters
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Update language bindings for parametric datatype sort API
- Python: Updated DatatypeSort() to accept optional params list
- OCaml: Added mk_sort_ref_p/mk_sort_ref_ps for parametric datatypes
- .NET: Added MkDatatypeSortRef() methods with optional params
- Java: Added mkDatatypeSortRef() methods with optional params
- All changes maintain backward compatibility
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Fix .NET build error - rename params to parameters
The 'params' keyword is reserved in C#, causing compilation errors.
Renamed parameter from 'params' to 'parameters' in MkDatatypeSortRef methods.
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Add unit test for parametric datatypes
Added test_parametric_datatype.cpp to demonstrate polymorphic datatypes.
The test creates two concrete instantiations of a generic pair concept:
- pair_int_real with fields (first:Int, second:Real)
- pair_real_int with fields (first:Real, second:Int)
Then verifies that accessors work correctly and type checking is enforced.
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Implement polymorphic type variables support for parametric datatypes
- Modified datatype_decl_plugin to allow type variables as parameters
- Updated mk_datatype_decl to extract type variables from field sorts
- Type variables are collected in order of first appearance
- Revised unit test to use Z3_mk_type_variable for polymorphic datatypes
- Test creates pair datatype with type variables alpha and beta
- Successfully instantiates with concrete types (pair Int Real) and (pair Real Int)
- Verifies accessor types match and equality terms are well-typed
- All tests pass
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Add Z3_mk_polymorphic_datatype API and refactor datatype creation
- Added new API Z3_mk_polymorphic_datatype to z3_api.h
- Renamed static mk_datatype_decl to api_datatype_decl in api_datatype.cpp
- Modified api_datatype_decl to accept explicit type parameters
- Updated all callers to use renamed function
- Added test_polymorphic_datatype_api demonstrating new API usage
- Both tests pass successfully
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Remove type variable collection logic from constructors
Removed the logic for collecting type variables from field sorts based on constructors.
* Update comments on parameter handling in api_datatype.cpp
Clarify usage of parameters in API documentation.
* Fix OCaml build error - use list instead of array for mk_datatype_sort
Changed mk_sort_ref to pass empty list [] instead of empty array [||].
Changed mk_sort_ref_p to pass params list directly instead of converting to array.
Z3native.mk_datatype_sort expects a list, not an array.
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Add polymorphic datatype example to C++ examples
Added polymorphic_datatype_example() demonstrating:
- Creating type variables alpha and beta with Z3_mk_type_variable
- Defining parametric Pair datatype with fields of type alpha and beta
- Instantiating with concrete types (Pair Int Real) and (Pair Real Int)
- Getting constructors and accessors from instantiated datatypes
- Creating constants and expressions using the polymorphic types
- Verifying type correctness with equality (= (first p1) (second p2))
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
---------
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
Co-authored-by: Nikolaj Bjorner <nbjorner@microsoft.com>
* trim parametric datatype test
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
* restore single cell
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* restore the method behavior
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* setting up python tuning experiment, not done
* Add finite_set_value_factory for creating finite set values in model generation (#7981)
* Initial plan
* Add finite_set_value_factory implementation
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Remove unused dl_decl_plugin variable and include
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Update copyright and add TODOs in finite_set_value_factory
Updated copyright information and added TODO comments for handling in finite_set_value_factory methods.
* Update copyright information in finite_set_value_factory.h
Updated copyright year from 2006 to 2025.
* Implement finite_set_value_factory using array_util to create singleton sets
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Simplify empty set creation in finite_set_value_factory
Refactor finite_set_value_factory to simplify empty set handling and remove array-specific logic.
* Change family ID for finite_set_value_factory
* Fix build error by restoring array_decl_plugin include and implementation
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
* Update finite_set_value_factory.h
* Add SASSERT for finite set check in factory
Added assertion to check if the sort is a finite set.
* Rename member variable from m_util to u
* Refactor finite_set_value_factory for value handling
* Use register_value instead of direct set insertion
Replaced direct insertion into set with register_value calls.
* Update finite_set_value_factory.cpp
---------
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
Co-authored-by: Nikolaj Bjorner <nbjorner@microsoft.com>
* Revert "Add finite_set_value_factory for creating finite set values in model …" (#7985)
This reverts commit 05ffc0a77b.
* Update arith_rewriter.cpp
fix memory leak introduced by update to ensure determinism
* update pythonnn prototyping experiment, need to add a couple more things
* add explicit constructors for nightly mac build failure
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
* build fixes
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
* fixes
* fix some more things but now it hangs
* change multithread to multiprocess seems to have resolved current deadlock
* fix some bugs, it seems to run now
* fix logic about checking clauses individually, and add proof prefix clause selection (naively) via the OnClause hook
* disable manylinux until segfault is resolved
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
* add the "noexcept" keyword to value_score=(value_score&&) declaration
* expose a status flag for clauses but every single one is being coded as an assumption...
* Add a fast-path to _coerce_exprs. (#7995)
When the inputs are already the same sort, we can skip most of the
coercion logic and just return.
Currently, `_coerce_exprs` is by far the most expensive part of
building up many common Z3 ASTs, so this fast-path is a substantial
speedup for many use-cases.
* Bump actions/setup-node from 5 to 6 (#7994)
Bumps [actions/setup-node](https://github.com/actions/setup-node) from 5 to 6.
- [Release notes](https://github.com/actions/setup-node/releases)
- [Commits](https://github.com/actions/setup-node/compare/v5...v6)
---
updated-dependencies:
- dependency-name: actions/setup-node
dependency-version: '6'
dependency-type: direct:production
update-type: version-update:semver-major
...
Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
* Enabling Control Flow Guard (CFG) by default for MSVC on Windows, with options to disable CFG. (#7988)
* Enabling Control Flow Guard by default for MSVC on Windows, with options to disable it.
* Fix configuration error for non-MSVC compilers.
* Reviewed and updated configuration for Python build and added comment for CFG.
* try exponential delay in grobner
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* throttle grobner method more actively
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* enable always add all coeffs in nlsat
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
* initial parameter probe thread setup in C++
* more param tuning setup
* setting up the param probe solvers and mutation generator
* adding the learned clauses from the internalizer
* fix some things for clause replay
* score the param probes, but i can't figure out how to access the relevant solver statistics fields from the statistics obj
* set up pattern to notify batch manager so worker threads can update their params according
ly
---------
Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
Co-authored-by: Nikolaj Bjorner <nbjorner@microsoft.com>
Co-authored-by: Lev Nachmanson <levnach@hotmail.com>
Co-authored-by: Nelson Elhage <nelhage@nelhage.com>
Co-authored-by: hwisungi <hwisungi@users.noreply.github.com>
This commit is contained in:
Ilana Shapiro
GitHub
parent
9369a14825
commit
e4a285187b
17 changed files with 454 additions and 46 deletions
|
|
@ -47,9 +47,22 @@ namespace nla {
|
|||
if (m_quota == 0)
|
||||
m_quota = c().params().arith_nl_gr_q();
|
||||
|
||||
bool const use_exp_delay = c().params().arith_nl_grobner_exp_delay();
|
||||
|
||||
if (m_quota == 1) {
|
||||
m_delay_base++;
|
||||
m_delay = m_delay_base;
|
||||
if (use_exp_delay) {
|
||||
constexpr unsigned delay_cap = 1000000;
|
||||
if (m_delay_base == 0)
|
||||
m_delay_base = 1;
|
||||
else if (m_delay_base < delay_cap) {
|
||||
m_delay_base *= 2;
|
||||
if (m_delay_base > delay_cap)
|
||||
m_delay_base = delay_cap;
|
||||
}
|
||||
m_delay = m_delay_base;
|
||||
}
|
||||
else
|
||||
m_delay = ++m_delay_base;
|
||||
m_quota = c().params().arith_nl_gr_q();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@ namespace nlsat {
|
|||
bool m_full_dimensional;
|
||||
bool m_minimize_cores;
|
||||
bool m_factor;
|
||||
bool m_add_all_coeffs;
|
||||
bool m_signed_project;
|
||||
bool m_cell_sample;
|
||||
|
||||
|
|
@ -154,6 +155,7 @@ namespace nlsat {
|
|||
m_simplify_cores = false;
|
||||
m_full_dimensional = false;
|
||||
m_minimize_cores = false;
|
||||
m_add_all_coeffs = true;
|
||||
m_signed_project = false;
|
||||
}
|
||||
|
||||
|
|
@ -622,6 +624,8 @@ namespace nlsat {
|
|||
//"An improved projection operation for cylindrical algebraic decomposition of three-dimensional space", by McCallum, Scott
|
||||
|
||||
bool is_square_free(polynomial_ref_vector &ps, var x) {
|
||||
if (m_add_all_coeffs)
|
||||
return false;
|
||||
polynomial_ref p(m_pm);
|
||||
polynomial_ref lc_poly(m_pm);
|
||||
polynomial_ref disc_poly(m_pm);
|
||||
|
|
@ -2135,6 +2139,10 @@ namespace nlsat {
|
|||
m_imp->m_factor = f;
|
||||
}
|
||||
|
||||
void explain::set_add_all_coeffs(bool f) {
|
||||
m_imp->m_add_all_coeffs = f;
|
||||
}
|
||||
|
||||
void explain::set_signed_project(bool f) {
|
||||
m_imp->m_signed_project = f;
|
||||
}
|
||||
|
|
@ -2185,4 +2193,3 @@ void pp_lit(nlsat::explain::imp & ex, nlsat::literal l) {
|
|||
std::cout << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@ namespace nlsat {
|
|||
void set_full_dimensional(bool f);
|
||||
void set_minimize_cores(bool f);
|
||||
void set_factor(bool f);
|
||||
void set_add_all_coeffs(bool f);
|
||||
void set_signed_project(bool f);
|
||||
|
||||
/**
|
||||
|
|
@ -109,4 +110,3 @@ namespace nlsat {
|
|||
};
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -19,5 +19,6 @@ def_module_params('nlsat',
|
|||
('inline_vars', BOOL, False, "inline variables that can be isolated from equations (not supported in incremental mode)"),
|
||||
('seed', UINT, 0, "random seed."),
|
||||
('factor', BOOL, True, "factor polynomials produced during conflict resolution."),
|
||||
('add_all_coeffs', BOOL, False, "add all polynomial coefficients during projection."),
|
||||
('known_sat_assignment_file_name', STRING, "", "the file name of a known solution: used for debugging only")
|
||||
))
|
||||
|
|
|
|||
|
|
@ -306,6 +306,7 @@ namespace nlsat {
|
|||
m_explain.set_simplify_cores(m_simplify_cores);
|
||||
m_explain.set_minimize_cores(min_cores);
|
||||
m_explain.set_factor(p.factor());
|
||||
m_explain.set_add_all_coeffs(p.add_all_coeffs());
|
||||
m_am.updt_params(p.p);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -80,6 +80,7 @@ def_module_params(module_name='smt',
|
|||
('arith.nl.grobner_cnfl_to_report', UINT, 1, 'grobner\'s maximum number of conflicts to report'),
|
||||
('arith.nl.grobner_propagate_quotients', BOOL, True, 'detect conflicts x*y + z = 0 where x doesn\'t divide z'),
|
||||
('arith.nl.grobner_gcd_test', BOOL, True, 'detect gcd conflicts for polynomial powers x^k - y = 0'),
|
||||
('arith.nl.grobner_exp_delay', BOOL, True, 'use exponential delay between grobner basis attempts'),
|
||||
('arith.nl.gr_q', UINT, 10, 'grobner\'s quota'),
|
||||
('arith.nl.grobner_subs_fixed', UINT, 1, '0 - no subs, 1 - substitute, 2 - substitute fixed zeros only'),
|
||||
('arith.nl.grobner_expand_terms', BOOL, True, 'expand terms before computing grobner basis'),
|
||||
|
|
@ -138,4 +139,3 @@ def_module_params(module_name='smt',
|
|||
('dt_lazy_splits', UINT, 1, 'How lazy datatype splits are performed: 0- eager, 1- lazy for infinite types, 2- lazy'),
|
||||
('qsat_use_qel', BOOL, True, 'Use QEL for lite quantifier elimination and model-based projection in QSAT')
|
||||
))
|
||||
|
||||
|
|
|
|||
|
|
@ -22,6 +22,11 @@ Revision History:
|
|||
|
||||
void theory_arith_params::updt_params(params_ref const & _p) {
|
||||
smt_params_helper p(_p);
|
||||
m_nl_arith_delay = p.arith_nl_delay();
|
||||
m_nl_arith_expensive_patching = p.arith_nl_expensive_patching();
|
||||
m_nl_arith_horner = p.arith_nl_horner();
|
||||
m_nl_arith_horner_frequency = p.arith_nl_horner_frequency();
|
||||
m_nl_arith_tangents = p.arith_nl_tangents();
|
||||
m_arith_random_initial_value = p.arith_random_initial_value();
|
||||
m_arith_random_seed = p.random_seed();
|
||||
m_arith_mode = static_cast<arith_solver_id>(p.arith_solver());
|
||||
|
|
@ -102,4 +107,9 @@ void theory_arith_params::display(std::ostream & out) const {
|
|||
DISPLAY_PARAM(m_arith_validate);
|
||||
DISPLAY_PARAM(m_arith_dump_lemmas);
|
||||
DISPLAY_PARAM(m_arith_epsilon);
|
||||
DISPLAY_PARAM(m_nl_arith_delay);
|
||||
DISPLAY_PARAM(m_nl_arith_expensive_patching);
|
||||
DISPLAY_PARAM(m_nl_arith_horner);
|
||||
DISPLAY_PARAM(m_nl_arith_horner_frequency);
|
||||
DISPLAY_PARAM(m_nl_arith_tangents);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -112,6 +112,11 @@ struct theory_arith_params {
|
|||
bool m_nl_arith_propagate_linear_monomials = true;
|
||||
bool m_nl_arith_optimize_bounds = true;
|
||||
bool m_nl_arith_cross_nested = true;
|
||||
unsigned m_nl_arith_delay = 10;
|
||||
bool m_nl_arith_expensive_patching = false;
|
||||
bool m_nl_arith_horner = true;
|
||||
unsigned m_nl_arith_horner_frequency = 4;
|
||||
bool m_nl_arith_tangents = true;
|
||||
|
||||
theory_arith_params(params_ref const & p = params_ref()) {
|
||||
updt_params(p);
|
||||
|
|
|
|||
|
|
@ -137,6 +137,7 @@ namespace smt {
|
|||
scoped_ptr<base_dependent_expr_state> m_fmls;
|
||||
|
||||
svector<double> m_lit_scores[2];
|
||||
vector<literal_vector> m_recorded_clauses;
|
||||
|
||||
|
||||
// -----------------------------------
|
||||
|
|
@ -1301,6 +1302,8 @@ namespace smt {
|
|||
|
||||
void add_scores(unsigned n, literal const *lits);
|
||||
|
||||
void record_clause(unsigned n, literal const * lits);
|
||||
|
||||
|
||||
// -----------------------------------
|
||||
//
|
||||
|
|
|
|||
|
|
@ -965,17 +965,24 @@ namespace smt {
|
|||
return v;
|
||||
}
|
||||
|
||||
// following the pattern of solver::persist_clause in src/sat/smt/user_solver.cpp
|
||||
void context::record_clause(unsigned num_lits, literal const *lits) {
|
||||
literal_vector clause;
|
||||
clause.append(num_lits, lits);
|
||||
m_recorded_clauses.push_back(clause);
|
||||
}
|
||||
|
||||
void context::add_scores(unsigned n, literal const *lits) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
auto lit = lits[i];
|
||||
unsigned v = lit.var(); // unique key per literal
|
||||
m_lit_scores[lit.sign()][v] += 1.0 / n;
|
||||
unsigned v = lit.var(); // uniq0 / n;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void context::undo_mk_bool_var() {
|
||||
SASSERT(!m_b_internalized_stack.empty());
|
||||
SASSERT(!m_b_internalized_stack.empty(ue key per literal
|
||||
m_lit_scores[lit.sign()][v] += 1.));
|
||||
m_stats.m_num_del_bool_var++;
|
||||
expr * n = m_b_internalized_stack.back();
|
||||
unsigned n_id = n->get_id();
|
||||
|
|
@ -1433,6 +1440,7 @@ namespace smt {
|
|||
case CLS_LEARNED:
|
||||
dump_lemma(num_lits, lits);
|
||||
add_scores(num_lits, lits);
|
||||
record_clause(num_lits, lits);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -64,6 +64,122 @@ namespace smt {
|
|||
|
||||
namespace smt {
|
||||
|
||||
lbool parallel::param_generator::run_prefix_step() {
|
||||
IF_VERBOSE(1, verbose_stream() << " Param generator running prefix step\n");
|
||||
ctx->get_fparams().m_max_conflicts = m_max_prefix_conflicts;
|
||||
lbool r = l_undef;
|
||||
try {
|
||||
r = ctx->check();
|
||||
} catch (z3_error &err) {
|
||||
b.set_exception(err.error_code());
|
||||
} catch (z3_exception &ex) {
|
||||
b.set_exception(ex.what());
|
||||
} catch (...) {
|
||||
b.set_exception("unknown exception");
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
unsigned parallel::param_generator::replay_proof_prefixes(vector<smt_params> candidate_param_states, unsigned max_conflicts_epsilon=200) {
|
||||
unsigned conflict_budget = m_max_prefix_conflicts + max_conflicts_epsilon;
|
||||
unsigned best_param_state_idx;
|
||||
double best_score;
|
||||
|
||||
for (unsigned i = 0; i < m_param_probe_contexts.size(); ++i) {
|
||||
IF_VERBOSE(1, verbose_stream() << " PARAM TUNER: replaying proof prefix in param probe context " << i << "\n");
|
||||
context *probe_ctx = m_param_probe_contexts[i];
|
||||
probe_ctx->get_fparams().m_max_conflicts = conflict_budget;
|
||||
double score = 0.0;
|
||||
|
||||
// apply the ith param state to probe_ctx
|
||||
smt_params params = candidate_param_states[i];
|
||||
params_ref p;
|
||||
params.updt_params(p);
|
||||
probe_ctx->updt_params(p);
|
||||
|
||||
for (auto const& clause : probe_ctx->m_recorded_clauses) {
|
||||
expr_ref_vector negated_lits(probe_ctx->m);
|
||||
for (literal lit : clause) {
|
||||
expr* e = probe_ctx->bool_var2expr(lit.var());
|
||||
if (!e) continue; // skip if var not yet mapped
|
||||
if (!lit.sign())
|
||||
e = probe_ctx->m.mk_not(e); // since bool_var2expr discards sign
|
||||
negated_lits.push_back(e);
|
||||
}
|
||||
|
||||
// Replay the negated clause
|
||||
lbool r = probe_ctx->check(negated_lits.size(), negated_lits.data());
|
||||
|
||||
::statistics st;
|
||||
probe_ctx->collect_statistics(st);
|
||||
unsigned conflicts = 0, decisions = 0, rlimit = 0;
|
||||
|
||||
// I can't figure out how to access the statistics fields, I only see an update method
|
||||
// st.get_uint("conflicts", conflicts);
|
||||
// st.get_uint("decisions", decisions);
|
||||
// st.get_uint("rlimit count", rlimit);
|
||||
score += conflicts + decisions + rlimit;
|
||||
}
|
||||
|
||||
if (i == 0 || score < best_score) {
|
||||
best_score = score;
|
||||
best_param_state_idx = i;
|
||||
}
|
||||
}
|
||||
|
||||
return best_param_state_idx;
|
||||
}
|
||||
|
||||
void parallel::param_generator::protocol_iteration() {
|
||||
IF_VERBOSE(1, verbose_stream() << " PARAM TUNER running protocol iteration\n");
|
||||
ctx->get_fparams().m_max_conflicts = m_max_prefix_conflicts;
|
||||
|
||||
// copy current param state to all param probe contexts, before running the next prefix step
|
||||
// this ensures that each param probe context replays the prefix from the same configuration
|
||||
for (unsigned i = 0; i < m_param_probe_contexts.size(); ++i) {
|
||||
context::copy(*ctx, *m_param_probe_contexts[i], true);
|
||||
}
|
||||
|
||||
lbool r = run_prefix_step();
|
||||
|
||||
switch (r) {
|
||||
case l_undef: {
|
||||
smt_params best_param_state = m_param_state;
|
||||
vector<smt_params> candidate_param_states;
|
||||
|
||||
candidate_param_states.push_back(best_param_state); // first candidate param state is current best
|
||||
while (candidate_param_states.size() <= N) {
|
||||
candidate_param_states.push_back(mutate_param_state());
|
||||
}
|
||||
|
||||
unsigned best_param_state_idx = replay_proof_prefixes(candidate_param_states);
|
||||
|
||||
if (best_param_state_idx != 0) {
|
||||
m_param_state = candidate_param_states[best_param_state_idx];
|
||||
b.set_param_state(m_param_state);
|
||||
IF_VERBOSE(1, verbose_stream() << " PARAM TUNER found better param state at index " << best_param_state_idx << "\n");
|
||||
} else {
|
||||
IF_VERBOSE(1, verbose_stream() << " PARAM TUNER retained current param state\n");
|
||||
}
|
||||
}
|
||||
case l_true: {
|
||||
IF_VERBOSE(1, verbose_stream() << " PARAM TUNER found formula sat\n");
|
||||
model_ref mdl;
|
||||
ctx->get_model(mdl);
|
||||
b.set_sat(m_l2g, *mdl);
|
||||
return;
|
||||
}
|
||||
case l_false: {
|
||||
expr_ref_vector const &unsat_core = ctx->unsat_core();
|
||||
IF_VERBOSE(2, verbose_stream() << " unsat core:\n";
|
||||
for (auto c : unsat_core) verbose_stream() << mk_bounded_pp(c, m, 3) << "\n");
|
||||
IF_VERBOSE(1, verbose_stream() << " PARAM TUNER determined formula unsat\n");
|
||||
b.set_unsat(m_l2g, unsat_core);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void parallel::worker::run() {
|
||||
search_tree::node<cube_config> *node = nullptr;
|
||||
expr_ref_vector cube(m);
|
||||
|
|
@ -77,6 +193,13 @@ namespace smt {
|
|||
|
||||
check_cube_start:
|
||||
LOG_WORKER(1, " CUBE SIZE IN MAIN LOOP: " << cube.size() << "\n");
|
||||
|
||||
// apply current best param state from batch manager
|
||||
smt_params params = b.get_best_param_state();
|
||||
params_ref p;
|
||||
params.updt_params(p);
|
||||
ctx->updt_params(p);
|
||||
|
||||
lbool r = check_cube(cube);
|
||||
|
||||
if (!m.inc()) {
|
||||
|
|
@ -143,6 +266,21 @@ namespace smt {
|
|||
m_num_initial_atoms = ctx->get_num_bool_vars();
|
||||
}
|
||||
|
||||
parallel::param_generator::param_generator(parallel& p)
|
||||
: p(p), b(p.m_batch_manager), m_param_state(p.ctx.get_fparams()), m_p(p.ctx.get_params()), m_l2g(m, p.ctx.m) {
|
||||
ctx = alloc(context, m, m_param_state, m_p);
|
||||
context::copy(p.ctx, *ctx, true);
|
||||
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
m_param_probe_contexts.push_back(alloc(context, m, m_param_state, m_p));
|
||||
}
|
||||
|
||||
// don't share initial units
|
||||
ctx->pop_to_base_lvl();
|
||||
init_param_state();
|
||||
IF_VERBOSE(1, verbose_stream() << "Initialized parameter generator\n");
|
||||
}
|
||||
|
||||
void parallel::worker::share_units() {
|
||||
// Collect new units learned locally by this worker and send to batch manager
|
||||
ctx->pop_to_base_lvl();
|
||||
|
|
@ -294,6 +432,11 @@ namespace smt {
|
|||
}
|
||||
}
|
||||
|
||||
smt_params parallel::batch_manager::get_best_param_state() {
|
||||
std::scoped_lock lock(mux);
|
||||
return m_param_state;
|
||||
}
|
||||
|
||||
void parallel::worker::collect_shared_clauses() {
|
||||
expr_ref_vector new_clauses = b.return_shared_clauses(m_g2l, m_shared_clause_limit, id);
|
||||
// iterate over new clauses and assert them in the local context
|
||||
|
|
@ -489,15 +632,19 @@ namespace smt {
|
|||
SASSERT(num_threads > 1);
|
||||
for (unsigned i = 0; i < num_threads; ++i)
|
||||
m_workers.push_back(alloc(worker, i, *this, asms));
|
||||
|
||||
|
||||
for (auto w : m_workers)
|
||||
sl.push_child(&(w->limit()));
|
||||
|
||||
sl.push_child(&(m_param_generator.limit()));
|
||||
|
||||
// Launch threads
|
||||
vector<std::thread> threads(num_threads);
|
||||
for (unsigned i = 0; i < num_threads; ++i) {
|
||||
vector<std::thread> threads(num_threads + 1); // +1 for parameter generator
|
||||
for (unsigned i = 0; i < num_threads - 1; ++i) {
|
||||
threads[i] = std::thread([&, i]() { m_workers[i]->run(); });
|
||||
}
|
||||
// the final thread runs the parameter generator
|
||||
threads[num_threads - 1] = std::thread([&]() { m_param_generator.protocol_iteration(); });
|
||||
|
||||
// Wait for all threads to finish
|
||||
for (auto &th : threads)
|
||||
|
|
|
|||
|
|
@ -20,12 +20,30 @@ Revision History:
|
|||
|
||||
#include "smt/smt_context.h"
|
||||
#include "util/search_tree.h"
|
||||
// #include "util/util.h"
|
||||
#include <thread>
|
||||
#include <mutex>
|
||||
|
||||
|
||||
namespace smt {
|
||||
|
||||
inline bool operator==(const smt_params& a, const smt_params& b) {
|
||||
return a.m_nl_arith_branching == b.m_nl_arith_branching &&
|
||||
a.m_nl_arith_cross_nested == b.m_nl_arith_cross_nested &&
|
||||
a.m_nl_arith_delay == b.m_nl_arith_delay &&
|
||||
a.m_nl_arith_expensive_patching == b.m_nl_arith_expensive_patching &&
|
||||
a.m_nl_arith_gb == b.m_nl_arith_gb &&
|
||||
a.m_nl_arith_horner == b.m_nl_arith_horner &&
|
||||
a.m_nl_arith_horner_frequency == b.m_nl_arith_horner_frequency &&
|
||||
a.m_nl_arith_optimize_bounds == b.m_nl_arith_optimize_bounds &&
|
||||
a.m_nl_arith_propagate_linear_monomials == b.m_nl_arith_propagate_linear_monomials &&
|
||||
a.m_nl_arith_tangents == b.m_nl_arith_tangents;
|
||||
}
|
||||
|
||||
inline bool operator!=(const smt_params& a, const smt_params& b) {
|
||||
return !(a == b);
|
||||
}
|
||||
|
||||
struct cube_config {
|
||||
using literal = expr_ref;
|
||||
static bool literal_is_null(expr_ref const& l) { return l == nullptr; }
|
||||
|
|
@ -62,6 +80,7 @@ namespace smt {
|
|||
std::mutex mux;
|
||||
state m_state = state::is_running;
|
||||
stats m_stats;
|
||||
smt_params m_param_state;
|
||||
using node = search_tree::node<cube_config>;
|
||||
search_tree::tree<cube_config> m_search_tree;
|
||||
|
||||
|
|
@ -77,8 +96,6 @@ namespace smt {
|
|||
w->cancel();
|
||||
}
|
||||
|
||||
void init_parameters_state();
|
||||
|
||||
public:
|
||||
batch_manager(ast_manager& m, parallel& p) : m(m), p(p), m_search_tree(expr_ref(m)) { }
|
||||
|
||||
|
|
@ -88,8 +105,10 @@ namespace smt {
|
|||
void set_sat(ast_translation& l2g, model& m);
|
||||
void set_exception(std::string const& msg);
|
||||
void set_exception(unsigned error_code);
|
||||
void set_param_state(smt_params const& p) { m_param_state = p; }
|
||||
void collect_statistics(::statistics& st) const;
|
||||
|
||||
|
||||
smt_params get_best_param_state();
|
||||
bool get_cube(ast_translation& g2l, unsigned id, expr_ref_vector& cube, node*& n);
|
||||
void backtrack(ast_translation& l2g, expr_ref_vector const& core, node* n);
|
||||
void split(ast_translation& l2g, unsigned id, node* n, expr* atom);
|
||||
|
|
@ -107,11 +126,75 @@ namespace smt {
|
|||
// 3. pick winner configuration if any are better than current.
|
||||
// 4. update current configuration with the winner
|
||||
|
||||
class parameter_generator_thread {
|
||||
unsigned N; // number of prefix permutation testers
|
||||
scoped_ptr<context> prefix_solver;
|
||||
scoped_ptr_vector<context> testers; // N testers
|
||||
class param_generator {
|
||||
parallel& p;
|
||||
batch_manager& b;
|
||||
ast_manager m;
|
||||
scoped_ptr<context> ctx;
|
||||
ast_translation m_l2g;
|
||||
|
||||
unsigned N = 4; // number of prefix permutations to test (including current)
|
||||
unsigned m_max_prefix_conflicts = 1000;
|
||||
|
||||
scoped_ptr<context> m_prefix_solver;
|
||||
scoped_ptr_vector<context> m_param_probe_contexts;
|
||||
smt_params m_param_state;
|
||||
params_ref m_p;
|
||||
|
||||
private:
|
||||
void init_param_state() {
|
||||
m_param_state.m_nl_arith_branching = true;
|
||||
m_param_state.m_nl_arith_cross_nested = true;
|
||||
m_param_state.m_nl_arith_delay = 10;
|
||||
m_param_state.m_nl_arith_expensive_patching = false;
|
||||
m_param_state.m_nl_arith_gb = true;
|
||||
m_param_state.m_nl_arith_horner = true;
|
||||
m_param_state.m_nl_arith_horner_frequency = 4;
|
||||
m_param_state.m_nl_arith_optimize_bounds = true;
|
||||
m_param_state.m_nl_arith_propagate_linear_monomials = true;
|
||||
m_param_state.m_nl_arith_tangents = true;
|
||||
|
||||
m_param_state.updt_params(m_p);
|
||||
ctx->updt_params(m_p);
|
||||
};
|
||||
|
||||
smt_params mutate_param_state() {
|
||||
smt_params p = m_param_state;
|
||||
random_gen m_rand;
|
||||
|
||||
auto flip_bool = [&](bool &x) {
|
||||
if ((m_rand() % 2) == 0)
|
||||
x = !x;
|
||||
};
|
||||
|
||||
auto mutate_uint = [&](unsigned &x, unsigned lo, unsigned hi) {
|
||||
if ((m_rand() % 2) == 0)
|
||||
x = lo + (m_rand() % (hi - lo + 1));
|
||||
};
|
||||
|
||||
flip_bool(p.m_nl_arith_branching);
|
||||
flip_bool(p.m_nl_arith_cross_nested);
|
||||
mutate_uint(p.m_nl_arith_delay, 5, 20);
|
||||
flip_bool(p.m_nl_arith_expensive_patching);
|
||||
flip_bool(p.m_nl_arith_gb);
|
||||
flip_bool(p.m_nl_arith_horner);
|
||||
mutate_uint(p.m_nl_arith_horner_frequency, 2, 6);
|
||||
flip_bool(p.m_nl_arith_optimize_bounds);
|
||||
flip_bool(p.m_nl_arith_propagate_linear_monomials);
|
||||
flip_bool(p.m_nl_arith_tangents);
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
public:
|
||||
param_generator(parallel& p);
|
||||
lbool run_prefix_step();
|
||||
void protocol_iteration();
|
||||
unsigned replay_proof_prefixes(vector<smt_params> candidate_param_states, unsigned max_conflicts_epsilon);
|
||||
|
||||
reslimit& limit() {
|
||||
return m.limit();
|
||||
}
|
||||
};
|
||||
|
||||
class worker {
|
||||
|
|
@ -173,6 +256,7 @@ namespace smt {
|
|||
|
||||
batch_manager m_batch_manager;
|
||||
scoped_ptr_vector<worker> m_workers;
|
||||
param_generator m_param_generator;
|
||||
|
||||
public:
|
||||
parallel(context& ctx) :
|
||||
|
|
@ -180,7 +264,8 @@ namespace smt {
|
|||
num_threads(std::min(
|
||||
(unsigned)std::thread::hardware_concurrency(),
|
||||
ctx.get_fparams().m_threads)),
|
||||
m_batch_manager(ctx.m, *this) {}
|
||||
m_batch_manager(ctx.m, *this),
|
||||
m_param_generator(*this) {}
|
||||
|
||||
lbool operator()(expr_ref_vector const& asms);
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue