3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-07 18:05:21 +00:00

reworking cancellation

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2015-12-11 16:21:24 -08:00 committed by Christoph M. Wintersteiger
parent e08bfb62f8
commit 9769322690
145 changed files with 172 additions and 958 deletions

View file

@ -75,7 +75,8 @@ namespace api {
m_dtutil(m()),
m_last_result(m()),
m_ast_trail(m()),
m_replay_stack() {
m_replay_stack(),
m_pmanager(m_limit) {
m_error_code = Z3_OK;
m_print_mode = Z3_PRINT_SMTLIB_FULL;
@ -122,9 +123,8 @@ namespace api {
{
if (m_interruptable)
(*m_interruptable)();
m().set_cancel(true);
if (m_rcf_manager.get() != 0)
m_rcf_manager->set_cancel(true);
m_limit.cancel();
m().limit().cancel();
}
}
@ -323,7 +323,7 @@ namespace api {
// -----------------------
realclosure::manager & context::rcfm() {
if (m_rcf_manager.get() == 0) {
m_rcf_manager = alloc(realclosure::manager, m_rcf_qm);
m_rcf_manager = alloc(realclosure::manager, m_limit, m_rcf_qm);
}
return *(m_rcf_manager.get());
}

View file

@ -187,10 +187,12 @@ namespace api {
//
// -----------------------
private:
reslimit m_limit;
pmanager m_pmanager;
public:
polynomial::manager & pm() { return m_pmanager.pm(); }
reslimit & poly_limit() { return m_limit; }
// ------------------------
//
// RCF manager

View file

@ -29,17 +29,13 @@ Notes:
namespace api {
pmanager::pmanager():
m_pm(m_nm) {
pmanager::pmanager(reslimit& lim):
m_pm(lim, m_nm) {
}
pmanager::~pmanager() {
}
void pmanager::set_cancel(bool f) {
m_pm.set_cancel(f);
}
};
extern "C" {
@ -66,7 +62,7 @@ extern "C" {
polynomial_ref r(pm);
expr_ref _r(mk_c(c)->m());
{
cancel_eh<reslimit> eh(mk_c(c)->m().limit());
cancel_eh<reslimit> eh(mk_c(c)->poly_limit());
api::context::set_interruptable si(*(mk_c(c)), eh);
scoped_timer timer(mk_c(c)->params().m_timeout, &eh);
pm.psc_chain(_p, _q, v_x, rs);

View file

@ -28,10 +28,9 @@ namespace api {
polynomial::manager m_pm;
// TODO: add support for caching expressions -> polynomial and back
public:
pmanager();
pmanager(reslimit& limx);
virtual ~pmanager();
polynomial::manager & pm() { return m_pm; }
void set_cancel(bool f);
};
};

View file

@ -30,7 +30,7 @@ static rcmanager & rcfm(Z3_context c) {
}
static void reset_rcf_cancel(Z3_context c) {
rcfm(c).reset_cancel();
// no-op
}
static Z3_rcf_num from_rcnumeral(rcnumeral a) {

View file

@ -110,10 +110,6 @@ parameter arith_decl_plugin::translate(parameter const & p, decl_plugin & target
return parameter(_target.aw().mk_id(aw().idx2anum(p.get_ext_id())), true);
}
void arith_decl_plugin::set_cancel(bool f) {
if (m_aw)
m_aw->m_amanager.set_cancel(f);
}
void arith_decl_plugin::set_manager(ast_manager * m, family_id id) {
decl_plugin::set_manager(m, id);

View file

@ -211,7 +211,6 @@ public:
virtual expr * get_some_value(sort * s);
virtual void set_cancel(bool f);
};
/**
@ -398,9 +397,6 @@ public:
return m_manager.mk_eq(lhs, rhs);
}
void set_cancel(bool f) {
plugin().set_cancel(f);
}
};
#endif /* ARITH_DECL_PLUGIN_H_ */

View file

@ -1433,12 +1433,6 @@ ast_manager::~ast_manager() {
}
}
void ast_manager::set_cancel(bool f) {
for (unsigned i = 0; i < m_plugins.size(); i++) {
m_plugins[i]->set_cancel(f);
}
}
void ast_manager::compact_memory() {
m_alloc.consolidate();
unsigned capacity = m_ast_table.capacity();

View file

@ -932,7 +932,6 @@ public:
virtual ~decl_plugin() {}
virtual void finalize() {}
virtual void set_cancel(bool f) {}
virtual decl_plugin * mk_fresh() = 0;
@ -1472,9 +1471,6 @@ public:
~ast_manager();
// propagate cancellation signal to decl_plugins
void set_cancel(bool f);
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
bool has_trace_stream() const { return m_trace_stream != 0; }
std::ostream & trace_stream() { SASSERT(has_trace_stream()); return *m_trace_stream; }

View file

@ -87,9 +87,6 @@ public:
TRACE("name_exprs", tout << mk_ismt2_pp(n, m_rw.m()) << "\n---->\n" << mk_ismt2_pp(r, m_rw.m()) << "\n";);
}
virtual void set_cancel(bool f) {
m_rw.set_cancel(f);
}
virtual void reset() {
m_rw.reset();

View file

@ -37,9 +37,6 @@ public:
proof_ref & p // [OUT] proof for (iff n p)
) = 0;
virtual void set_cancel(bool f) = 0;
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
virtual void reset() = 0;
};

View file

@ -1032,9 +1032,6 @@ br_status arith_rewriter::mk_abs_core(expr * arg, expr_ref & result) {
return BR_REWRITE2;
}
void arith_rewriter::set_cancel(bool f) {
m_util.set_cancel(f);
}
// Return true if t is of the form c*Pi where c is a numeral.
// Store c into k

View file

@ -167,8 +167,6 @@ public:
}
br_status mk_is_int(expr * arg, expr_ref & result);
void set_cancel(bool f);
br_status mk_sin_core(expr * arg, expr_ref & result);
br_status mk_cos_core(expr * arg, expr_ref & result);
br_status mk_tan_core(expr * arg, expr_ref & result);

View file

@ -649,10 +649,6 @@ void bit_blaster_rewriter::updt_params(params_ref const& p) {
m_imp->m_cfg.updt_params(p);
}
void bit_blaster_rewriter::set_cancel(bool f) {
m_imp->set_cancel(f);
m_imp->m_blaster.set_cancel(f);
}
void bit_blaster_rewriter::push() {
m_imp->push();

View file

@ -30,7 +30,6 @@ public:
bit_blaster_rewriter(ast_manager & m, params_ref const & p);
~bit_blaster_rewriter();
void updt_params(params_ref const & p);
void set_cancel(bool f);
ast_manager & m() const;
unsigned get_num_steps() const;
void cleanup();

View file

@ -36,7 +36,6 @@ protected:
void mk_ext_rotate_left_right(unsigned sz, expr * const * a_bits, expr * const * b_bits, expr_ref_vector & out_bits);
unsigned long long m_max_memory;
volatile bool m_cancel;
bool m_use_wtm; /* Wallace Tree Multiplier */
bool m_use_bcm; /* Booth Multiplier for constants */
void checkpoint();
@ -45,7 +44,6 @@ public:
bit_blaster_tpl(Cfg const & cfg = Cfg(), unsigned long long max_memory = UINT64_MAX, bool use_wtm = false, bool use_bcm=false):
Cfg(cfg),
m_max_memory(max_memory),
m_cancel(false),
m_use_wtm(use_wtm),
m_use_bcm(use_bcm) {
}
@ -54,9 +52,6 @@ public:
m_max_memory = max_memory;
}
void set_cancel(bool f) { m_cancel = f; }
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
// Cfg required API
ast_manager & m() const { return Cfg::m(); }

View file

@ -27,7 +27,7 @@ template<typename Cfg>
void bit_blaster_tpl<Cfg>::checkpoint() {
if (memory::get_allocation_size() > m_max_memory)
throw rewriter_exception(Z3_MAX_MEMORY_MSG);
if (m_cancel)
if (m().canceled())
throw rewriter_exception(Z3_CANCELED_MSG);
cooperate("bit-blaster");
}

View file

@ -444,12 +444,6 @@ void der_rewriter::operator()(expr * t, expr_ref & result, proof_ref & result_pr
m_imp->operator()(t, result, result_pr);
}
void der_rewriter::set_cancel(bool f) {
#pragma omp critical (der_rewriter)
{
m_imp->set_cancel(f);
}
}
void der_rewriter::cleanup() {
ast_manager & m = m_imp->m();

View file

@ -174,9 +174,6 @@ public:
void operator()(expr * t, expr_ref & result, proof_ref & result_pr);
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
void set_cancel(bool f);
void cleanup();
void reset();
};

View file

@ -107,9 +107,6 @@ public:
}
}
virtual void set_cancel(bool f) {
m_replacer.set_cancel(f);
}
virtual unsigned get_num_steps() const {
return m_replacer.get_num_steps();
@ -146,10 +143,6 @@ public:
m_r.reset_used_dependencies();
}
virtual void set_cancel(bool f) {
m_r.set_cancel(f);
}
virtual unsigned get_num_steps() const {
return m_r.get_num_steps();
}

View file

@ -39,9 +39,6 @@ public:
virtual void operator()(expr * t, expr_ref & result);
virtual void operator()(expr_ref & t) { expr_ref s(t, m()); (*this)(s, t); }
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
virtual void set_cancel(bool f) = 0;
virtual unsigned get_num_steps() const { return 0; }
virtual void reset() = 0;

View file

@ -212,7 +212,6 @@ protected:
};
Config & m_cfg;
unsigned m_num_steps;
volatile bool m_cancel;
ptr_vector<expr> m_bindings;
var_shifter m_shifter;
expr_ref m_r;
@ -333,10 +332,6 @@ public:
Config & cfg() { return m_cfg; }
Config const & cfg() const { return m_cfg; }
void set_cancel(bool f) { m_cancel = f; }
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
~rewriter_tpl();
void reset();

View file

@ -495,7 +495,6 @@ rewriter_tpl<Config>::rewriter_tpl(ast_manager & m, bool proof_gen, Config & cfg
rewriter_core(m, proof_gen),
m_cfg(cfg),
m_num_steps(0),
m_cancel(false),
m_shifter(m),
m_r(m),
m_pr(m),
@ -576,8 +575,6 @@ template<bool ProofGen>
void rewriter_tpl<Config>::resume_core(expr_ref & result, proof_ref & result_pr) {
SASSERT(!frame_stack().empty());
while (!frame_stack().empty()) {
if (m_cancel)
throw rewriter_exception(Z3_CANCELED_MSG);
if (!m().canceled()) {
if (m().limit().cancel_flag_set()) {
throw rewriter_exception(Z3_CANCELED_MSG);

View file

@ -685,9 +685,6 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
return false;
}
void set_cancel(bool f) {
m_a_rw.set_cancel(f);
}
};
template class rewriter_tpl<th_rewriter_cfg>;
@ -734,13 +731,6 @@ unsigned th_rewriter::get_num_steps() const {
return m_imp->get_num_steps();
}
void th_rewriter::set_cancel(bool f) {
#pragma omp critical (th_rewriter)
{
m_imp->set_cancel(f);
m_imp->cfg().set_cancel(f);
}
}
void th_rewriter::cleanup() {
ast_manager & m = m_imp->m();

View file

@ -45,9 +45,6 @@ public:
void operator()(expr * t, expr_ref & result, proof_ref & result_pr);
void operator()(expr * n, unsigned num_bindings, expr * const * bindings, expr_ref & result);
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
void set_cancel(bool f);
void cleanup();
void reset();

View file

@ -352,16 +352,15 @@ cmd_context::~cmd_context() {
}
void cmd_context::set_cancel(bool f) {
if (m_solver) {
if (has_manager()) {
m().set_cancel(f);
if (f) {
m_solver->cancel();
m().limit().cancel();
}
else {
m_solver->reset_cancel();
m().limit().reset_cancel();
}
}
if (has_manager())
m().set_cancel(f);
}
opt_wrapper* cmd_context::get_opt() {
@ -1453,7 +1452,7 @@ void cmd_context::check_sat(unsigned num_assumptions, expr * const * assumptions
else if (m_solver) {
m_check_sat_result = m_solver.get(); // solver itself stores the result.
m_solver->set_progress_callback(this);
cancel_eh<solver> eh(*m_solver);
cancel_eh<reslimit> eh(m().limit());
scoped_ctrl_c ctrlc(eh);
scoped_timer timer(timeout, &eh);
scoped_rlimit _rlimit(m().limit(), rlimit);
@ -1612,7 +1611,7 @@ void cmd_context::validate_model() {
model_evaluator evaluator(*(md.get()), p);
contains_array_op_proc contains_array(m());
{
cancel_eh<model_evaluator> eh(evaluator);
cancel_eh<reslimit> eh(m().limit());
expr_ref r(m());
scoped_ctrl_c ctrlc(eh);
ptr_vector<expr>::const_iterator it = begin_assertions();

View file

@ -64,7 +64,7 @@ public:
expr_ref r(ctx.m());
unsigned timeout = m_params.get_uint("timeout", UINT_MAX);
model_evaluator ev(*(md.get()), m_params);
cancel_eh<model_evaluator> eh(ev);
cancel_eh<reslimit> eh(ctx.m().limit());
{
scoped_ctrl_c ctrlc(eh);
scoped_timer timer(timeout, &eh);

View file

@ -33,7 +33,7 @@ Notes:
static void to_poly(cmd_context & ctx, expr * t) {
polynomial::numeral_manager nm;
polynomial::manager pm(nm);
polynomial::manager pm(ctx.m().limit(), nm);
default_expr2polynomial expr2poly(ctx.m(), pm);
polynomial::polynomial_ref p(pm);
polynomial::scoped_numeral d(nm);
@ -52,7 +52,7 @@ static void to_poly(cmd_context & ctx, expr * t) {
static void factor(cmd_context & ctx, expr * t, polynomial::factor_params const & ps) {
polynomial::numeral_manager nm;
polynomial::manager pm(nm);
polynomial::manager pm(ctx.m().limit(), nm);
default_expr2polynomial expr2poly(ctx.m(), pm);
polynomial::polynomial_ref p(pm);
polynomial::scoped_numeral d(nm);
@ -95,7 +95,7 @@ class poly_isolate_roots_cmd : public cmd {
context(ast_manager & m):
m_util(m),
m_pm(m_qm),
m_pm(m.limit(), m_qm),
m_am(m_lim, m_qm),
m_p(m_pm),
m_expr2poly(m, m_pm),

View file

@ -199,7 +199,7 @@ public:
ctx.set_check_sat_result(result.get());
{
tactic & t = *tref;
cancel_eh<tactic> eh(t);
cancel_eh<reslimit> eh(m.limit());
{
scoped_ctrl_c ctrlc(eh);
scoped_timer timer(timeout, &eh);
@ -310,7 +310,7 @@ public:
std::string reason_unknown;
bool failed = false;
cancel_eh<tactic> eh(t);
cancel_eh<reslimit> eh(m.limit());
{
scoped_ctrl_c ctrlc(eh);
scoped_timer timer(timeout, &eh);

View file

@ -936,8 +936,7 @@ namespace Duality {
void cancel(){
scoped_proof_mode spm(m(),m_mode);
canceled = true;
if(m_solver)
m_solver->cancel();
m().limit().cancel();
}
unsigned get_scope_level(){ scoped_proof_mode spm(m(),m_mode); return m_solver->get_scope_level();}

View file

@ -21,6 +21,7 @@ Revision History:
#include"mpq.h"
#include"ext_numeral.h"
#include"rlimit.h"
/**
\brief Default configuration for interval manager.
@ -110,6 +111,7 @@ public:
typedef typename numeral_manager::numeral numeral;
typedef typename C::interval interval;
private:
reslimit& m_limit;
C m_c;
numeral m_result_lower;
numeral m_result_upper;
@ -127,7 +129,6 @@ private:
interval m_3_pi_div_2;
interval m_2_pi;
volatile bool m_cancel;
void round_to_minus_inf() { m_c.round_to_minus_inf(); }
void round_to_plus_inf() { m_c.round_to_plus_inf(); }
@ -161,11 +162,9 @@ private:
void checkpoint();
public:
interval_manager(C const & c);
interval_manager(reslimit& lim, C const & c);
~interval_manager();
void set_cancel(bool f) { m_cancel = f; }
numeral_manager & m() const { return m_c.m(); }
void del(interval & a);

View file

@ -30,11 +30,10 @@ Revision History:
// #define TRACE_NTH_ROOT
template<typename C>
interval_manager<C>::interval_manager(C const & c):m_c(c) {
interval_manager<C>::interval_manager(reslimit& lim, C const & c): m_limit(lim), m_c(c) {
m().set(m_minus_one, -1);
m().set(m_one, 1);
m_pi_n = 0;
m_cancel = false;
}
template<typename C>
@ -63,7 +62,7 @@ void interval_manager<C>::del(interval & a) {
template<typename C>
void interval_manager<C>::checkpoint() {
if (m_cancel)
if (m_limit.canceled())
throw default_exception("canceled");
cooperate("interval");
}

View file

@ -83,7 +83,6 @@ namespace algebraic_numbers {
scoped_upoly m_add_tmp;
polynomial::var m_x;
polynomial::var m_y;
volatile bool m_cancel;
// configuration
int m_min_magnitude;
@ -104,8 +103,8 @@ namespace algebraic_numbers {
m_qmanager(m),
m_bqmanager(m),
m_bqimanager(m_bqmanager),
m_pmanager(m, &a),
m_upmanager(m),
m_pmanager(lim, m, &a),
m_upmanager(lim, m),
m_is_rational_tmp(m),
m_isolate_tmp1(upm()),
m_isolate_tmp2(upm()),
@ -118,7 +117,6 @@ namespace algebraic_numbers {
m_add_tmp(upm()) {
updt_params(p);
reset_statistics();
m_cancel = false;
m_x = pm().mk_var();
m_y = pm().mk_var();
}
@ -126,14 +124,8 @@ namespace algebraic_numbers {
~imp() {
}
void set_cancel(bool f) {
m_cancel = f;
pm().set_cancel(f);
upm().set_cancel(f);
}
void checkpoint() {
if (m_cancel)
if (!m_limit.inc())
throw algebraic_exception("canceled");
cooperate("algebraic");
}
@ -2785,10 +2777,6 @@ namespace algebraic_numbers {
void manager::updt_params(params_ref const & p) {
}
void manager::set_cancel(bool f) {
m_imp->set_cancel(f);
}
unsynch_mpq_manager & manager::qm() const {
return m_imp->qm();
}

View file

@ -64,10 +64,6 @@ namespace algebraic_numbers {
static void get_param_descrs(param_descrs & r);
static void collect_param_descrs(param_descrs & r) { get_param_descrs(r); }
void set_cancel(bool f);
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
void updt_params(params_ref const & p);
unsynch_mpq_manager & qm() const;

View file

@ -1829,6 +1829,7 @@ namespace polynomial {
typedef _scoped_numeral<numeral_manager> scoped_numeral;
typedef _scoped_numeral_vector<numeral_manager> scoped_numeral_vector;
reslimit& m_limit;
manager & m_wrapper;
numeral_manager m_manager;
up_manager m_upm;
@ -1847,7 +1848,6 @@ namespace polynomial {
unsigned_vector m_degree2pos;
bool m_use_sparse_gcd;
bool m_use_prs_gcd;
volatile bool m_cancel;
// Debugging method: check if the coefficients of p are in the numeral_manager.
bool consistent_coeffs(polynomial const * p) {
@ -2323,13 +2323,13 @@ namespace polynomial {
inc_ref(m_unit_poly);
m_use_sparse_gcd = true;
m_use_prs_gcd = false;
m_cancel = false;
}
imp(manager & w, unsynch_mpz_manager & m, monomial_manager * mm):
imp(reslimit& lim, manager & w, unsynch_mpz_manager & m, monomial_manager * mm):
m_limit(lim),
m_wrapper(w),
m_manager(m),
m_upm(m) {
m_upm(lim, m) {
if (mm == 0)
mm = alloc(monomial_manager);
m_monomial_manager = mm;
@ -2337,10 +2337,11 @@ namespace polynomial {
init();
}
imp(manager & w, unsynch_mpz_manager & m, small_object_allocator * a):
imp(reslimit& lim, manager & w, unsynch_mpz_manager & m, small_object_allocator * a):
m_limit(lim),
m_wrapper(w),
m_manager(m),
m_upm(m) {
m_upm(lim, m) {
m_monomial_manager = alloc(monomial_manager, a);
m_monomial_manager->inc_ref();
init();
@ -2371,13 +2372,8 @@ namespace polynomial {
m_monomial_manager->dec_ref();
}
void set_cancel(bool f) {
m_cancel = f;
m_upm.set_cancel(f);
}
void checkpoint() {
if (m_cancel) {
if (!m_limit.inc()) {
throw polynomial_exception("canceled");
}
cooperate("polynomial");
@ -6883,12 +6879,12 @@ namespace polynomial {
}
};
manager::manager(numeral_manager & m, monomial_manager * mm) {
m_imp = alloc(imp, *this, m, mm);
manager::manager(reslimit& lim, numeral_manager & m, monomial_manager * mm) {
m_imp = alloc(imp, lim, *this, m, mm);
}
manager::manager(numeral_manager & m, small_object_allocator * a) {
m_imp = alloc(imp, *this, m, a);
manager::manager(reslimit& lim, numeral_manager & m, small_object_allocator * a) {
m_imp = alloc(imp, lim, *this, m, a);
}
manager::~manager() {
@ -6927,10 +6923,6 @@ namespace polynomial {
return m_imp->mm().allocator();
}
void manager::set_cancel(bool f) {
m_imp->set_cancel(f);
}
void manager::add_del_eh(del_eh * eh) {
m_imp->add_del_eh(eh);
}

View file

@ -28,6 +28,7 @@ Notes:
#include"scoped_numeral_vector.h"
#include"params.h"
#include"mpbqi.h"
#include"rlimit.h"
class small_object_allocator;
@ -190,8 +191,8 @@ namespace polynomial {
private:
imp * m_imp;
public:
manager(numeral_manager & m, monomial_manager * mm = 0);
manager(numeral_manager & m, small_object_allocator * a);
manager(reslimit& lim, numeral_manager & m, monomial_manager * mm = 0);
manager(reslimit& lim, numeral_manager & m, small_object_allocator * a);
~manager();
numeral_manager & m() const;
@ -218,10 +219,6 @@ namespace polynomial {
void set_zp(numeral const & p);
void set_zp(uint64 p);
void set_cancel(bool f);
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
/**
\brief Abstract event handler.
*/

View file

@ -58,7 +58,6 @@ namespace rpolynomial {
numeral_manager & m_manager;
small_object_allocator * m_allocator;
bool m_own_allocator;
volatile bool m_cancel;
imp(manager & w, numeral_manager & m, small_object_allocator * a):
m_wrapper(w),
@ -67,7 +66,6 @@ namespace rpolynomial {
m_own_allocator(a == 0) {
if (a == 0)
m_allocator = alloc(small_object_allocator, "rpolynomial");
m_cancel = false;
}
~imp() {

View file

@ -57,8 +57,6 @@ namespace rpolynomial {
numeral_manager & m() const;
small_object_allocator & allocator() const;
void set_cancel(bool f);
/**
\brief Create a new variable.
*/

View file

@ -134,9 +134,9 @@ namespace upolynomial {
std::swap(m_total_degree, other.m_total_degree);
}
core_manager::core_manager(unsynch_mpz_manager & m):
core_manager::core_manager(reslimit& lim, unsynch_mpz_manager & m):
m_limit(lim),
m_manager(m) {
m_cancel = false;
}
core_manager::~core_manager() {
@ -153,12 +153,8 @@ namespace upolynomial {
reset(m_pw_tmp);
}
void core_manager::set_cancel(bool f) {
m_cancel = f;
}
void core_manager::checkpoint() {
if (m_cancel)
if (!m_limit.inc())
throw upolynomial_exception("canceled");
cooperate("upolynomial");
}

View file

@ -29,6 +29,7 @@ Notes:
#include"polynomial.h"
#include"z3_exception.h"
#include"mpbq.h"
#include"rlimit.h"
#define FACTOR_VERBOSE_LVL 1000
namespace upolynomial {
@ -101,6 +102,7 @@ namespace upolynomial {
};
protected:
reslimit& m_limit;
numeral_manager m_manager;
numeral_vector m_basic_tmp;
numeral_vector m_div_tmp1;
@ -114,7 +116,6 @@ namespace upolynomial {
numeral_vector m_sqf_tmp1;
numeral_vector m_sqf_tmp2;
numeral_vector m_pw_tmp;
volatile bool m_cancel;
static bool is_alias(numeral const * p, numeral_vector & buffer) { return buffer.c_ptr() != 0 && buffer.c_ptr() == p; }
void neg_core(unsigned sz1, numeral const * p1, numeral_vector & buffer);
@ -128,12 +129,12 @@ namespace upolynomial {
void CRA_combine_images(numeral_vector const & q, numeral const & p, numeral_vector & C, numeral & bound);
public:
core_manager(z_numeral_manager & m);
core_manager(reslimit& lim, z_numeral_manager & m);
~core_manager();
z_numeral_manager & zm() const { return m_manager.m(); }
numeral_manager & m() const { return const_cast<core_manager*>(this)->m_manager; }
reslimit& lim() const { return m_limit; }
/**
\brief Return true if Z_p[X]
*/
@ -156,7 +157,6 @@ namespace upolynomial {
void checkpoint();
void set_cancel(bool f);
/**
\brief set p size to 0. That is, p is the zero polynomial after this operation.
@ -576,7 +576,7 @@ namespace upolynomial {
bool factor_core(unsigned sz, numeral const * p, factors & r, factor_params const & params);
public:
manager(z_numeral_manager & m):core_manager(m) {}
manager(reslimit& lim, z_numeral_manager & m):core_manager(lim, m) {}
~manager();
void reset(numeral_vector & p) { core_manager::reset(p); }

View file

@ -518,7 +518,7 @@ bool check_hansel_lift(z_manager & upm, numeral_vector const & C,
scoped_mpz br(nm);
nm.mul(b, r, br);
zp_manager br_upm(upm.zm());
zp_manager br_upm(upm.lim(), upm.zm());
br_upm.set_zp(br);
if (A_lifted.size() != A.size()) return false;
@ -543,7 +543,7 @@ bool check_hansel_lift(z_manager & upm, numeral_vector const & C,
return false;
}
zp_manager b_upm(nm);
zp_manager b_upm(upm.lim(), nm);
b_upm.set_zp(b);
// test2: A_lifted = A (mod b)
@ -596,7 +596,7 @@ void hensel_lift(z_manager & upm, numeral const & a, numeral const & b, numeral
tout << "C = "; upm.display(tout, C); tout << ")" << endl;
);
zp_manager r_upm(nm);
zp_manager r_upm(upm.lim(), nm);
r_upm.set_zp(r);
SASSERT(upm.degree(C) == upm.degree(A) + upm.degree(B));
@ -717,7 +717,7 @@ void hensel_lift_quadratic(z_manager& upm, numeral_vector const & C,
);
// we create a new Z_p manager, since we'll be changing the input one
zp_manager zp_upm(nm);
zp_manager zp_upm(upm.lim(), nm);
zp_upm.set_zp(zpe_upm.m().p());
// get the U, V, such that A*U + B*V = 1 (mod p)
@ -1055,7 +1055,7 @@ bool factor_square_free(z_manager & upm, numeral_vector const & f, factors & fs,
// the variables we'll be using and updating in Z_p
scoped_numeral p(nm);
nm.set(p, 2);
zp_manager zp_upm(nm.m());
zp_manager zp_upm(upm.lim(), nm.m());
zp_upm.set_zp(p);
zp_factors zp_fs(zp_upm);
scoped_numeral zp_fs_p(nm); nm.set(zp_fs_p, 2);
@ -1163,7 +1163,7 @@ bool factor_square_free(z_manager & upm, numeral_vector const & f, factors & fs,
);
// we got a prime factoring, so we do the lifting now
zp_manager zpe_upm(nm.m());
zp_manager zpe_upm(upm.lim(), nm.m());
zpe_upm.set_zp(zp_fs_p);
zp_numeral_manager & zpe_nm = zpe_upm.m();

View file

@ -369,6 +369,7 @@ namespace realclosure {
typedef sbuffer<int, REALCLOSURE_INI_BUFFER_SIZE> int_buffer;
typedef sbuffer<unsigned, REALCLOSURE_INI_BUFFER_SIZE> unsigned_buffer;
reslimit& m_limit;
small_object_allocator * m_allocator;
bool m_own_allocator;
unsynch_mpq_manager & m_qm;
@ -400,7 +401,6 @@ namespace realclosure {
bool m_in_aux_values; // True if we are computing SquareFree polynomials or Sturm sequences. That is, the values being computed will be discarded.
volatile bool m_cancel;
struct scoped_polynomial_seq {
typedef ref_buffer<value, imp, REALCLOSURE_INI_SEQ_SIZE> value_seq;
@ -494,7 +494,8 @@ namespace realclosure {
#define INC_DEPTH() ((void) 0)
#endif
imp(unsynch_mpq_manager & qm, params_ref const & p, small_object_allocator * a):
imp(reslimit& lim, unsynch_mpq_manager & qm, params_ref const & p, small_object_allocator * a):
m_limit(lim),
m_allocator(a == 0 ? alloc(small_object_allocator, "realclosure") : a),
m_own_allocator(a == 0),
m_qm(qm),
@ -514,7 +515,6 @@ namespace realclosure {
m_in_aux_values = false;
m_cancel = false;
updt_params(p);
}
@ -547,7 +547,7 @@ namespace realclosure {
small_object_allocator & allocator() { return *m_allocator; }
void checkpoint() {
if (m_cancel)
if (!m_limit.inc())
throw exception("canceled");
cooperate("rcf");
}
@ -730,9 +730,6 @@ namespace realclosure {
return m_extensions[extension::ALGEBRAIC].size();
}
void set_cancel(bool f) {
m_cancel = f;
}
void updt_params(params_ref const & _p) {
rcf_params p(_p);
@ -6033,8 +6030,8 @@ namespace realclosure {
~save_interval_ctx() { m->restore_saved_intervals(); }
};
manager::manager(unsynch_mpq_manager & m, params_ref const & p, small_object_allocator * a) {
m_imp = alloc(imp, m, p, a);
manager::manager(reslimit& lim, unsynch_mpq_manager & m, params_ref const & p, small_object_allocator * a) {
m_imp = alloc(imp, lim, m, p, a);
}
manager::~manager() {
@ -6045,10 +6042,6 @@ namespace realclosure {
rcf_params::collect_param_descrs(r);
}
void manager::set_cancel(bool f) {
m_imp->set_cancel(f);
}
void manager::updt_params(params_ref const & p) {
m_imp->updt_params(p);
}

View file

@ -28,6 +28,7 @@ Notes:
#include"scoped_numeral_vector.h"
#include"interval.h"
#include"z3_exception.h"
#include"rlimit.h"
namespace realclosure {
class num;
@ -47,7 +48,7 @@ namespace realclosure {
friend class save_interval_ctx;
imp * m_imp;
public:
manager(unsynch_mpq_manager & m, params_ref const & p = params_ref(), small_object_allocator * a = 0);
manager(reslimit& lim, unsynch_mpq_manager & m, params_ref const & p = params_ref(), small_object_allocator * a = 0);
~manager();
typedef num numeral;
typedef svector<numeral> numeral_vector;
@ -57,9 +58,6 @@ namespace realclosure {
static void get_param_descrs(param_descrs & r);
static void collect_param_descrs(param_descrs & r) { get_param_descrs(r); }
void set_cancel(bool f);
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
void updt_params(params_ref const & p);

View file

@ -97,7 +97,6 @@ namespace simplex {
mutable eps_manager em;
mutable matrix M;
unsigned m_max_iterations;
volatile bool m_cancel;
var_heap m_to_patch;
vector<var_info> m_vars;
svector<var_t> m_row2base;

View file

@ -31,6 +31,7 @@ Revision History:
#include"statistics.h"
#include"lbool.h"
#include"id_gen.h"
#include"rlimit.h"
#ifdef _MSC_VER
#pragma warning(disable : 4200)
#pragma warning(disable : 4355)
@ -526,8 +527,6 @@ private:
numeral m_tmp1, m_tmp2, m_tmp3;
interval m_i_tmp1, m_i_tmp2, m_i_tmp3;
// Cancel flag
volatile bool m_cancel;
friend class node;
@ -759,7 +758,7 @@ private:
bool check_invariant() const;
public:
context_t(C const & c, params_ref const & p, small_object_allocator * a);
context_t(reslimit& lim, C const & c, params_ref const & p, small_object_allocator * a);
~context_t();
/**
@ -835,8 +834,6 @@ public:
void set_display_proc(display_var_proc * p) { m_display_proc = p; }
void set_cancel(bool f) { m_cancel = f; im().set_cancel(f); }
void updt_params(params_ref const & p);
static void collect_param_descrs(param_descrs & d);

View file

@ -431,7 +431,6 @@ context_t<C>::context_t(C const & c, params_ref const & p, small_object_allocato
m_node_selector = alloc(breadth_first_node_selector<C>, this);
m_var_selector = alloc(round_robing_var_selector<C>, this);
m_node_splitter = alloc(midpoint_node_splitter<C>, this);
m_cancel = false;
m_num_nodes = 0;
updt_params(p);
reset_statistics();
@ -459,7 +458,7 @@ context_t<C>::~context_t() {
template<typename C>
void context_t<C>::checkpoint() {
if (m_cancel)
if (m_limit.canceled())
throw default_exception("canceled");
if (memory::get_allocation_size() > m_max_memory)
throw default_exception(Z3_MAX_MEMORY_MSG);

View file

@ -51,7 +51,6 @@ struct expr2subpaving::imp {
obj_map<expr, subpaving::ineq*> m_lit_cache;
volatile bool m_cancel;
imp(ast_manager & m, subpaving::context & s, expr2var * e2v):
m_manager(m),
@ -71,7 +70,6 @@ struct expr2subpaving::imp {
m_expr2var_owner = false;
}
m_cancel = false;
}
~imp() {
@ -95,7 +93,7 @@ struct expr2subpaving::imp {
}
void checkpoint() {
if (m_cancel)
if (m().canceled())
throw default_exception("canceled");
cooperate("expr2subpaving");
}
@ -357,9 +355,6 @@ struct expr2subpaving::imp {
return m_expr2var->is_var(t);
}
void set_cancel(bool f) {
m_cancel = f;
}
subpaving::var internalize_term(expr * t, mpz & n, mpz & d) {
return process(t, 0, n, d);
@ -386,9 +381,6 @@ bool expr2subpaving::is_var(expr * t) const {
return m_imp->is_var(t);
}
void expr2subpaving::set_cancel(bool f) {
m_imp->set_cancel(f);
}
subpaving::var expr2subpaving::internalize_term(expr * t, mpz & n, mpz & d) {
return m_imp->internalize_term(t, n, d);

View file

@ -40,12 +40,7 @@ public:
\brief Return true if t was encoded as a variable by the translator.
*/
bool is_var(expr * t) const;
/**
\brief Cancel/Interrupt execution.
*/
void set_cancel(bool f);
/**
\brief Internalize a Z3 arithmetical expression into the subpaving data-structure.

View file

@ -124,7 +124,6 @@ class subpaving_tactic : public tactic {
}
void set_cancel(bool f) {
m_e2s->set_cancel(f);
m_ctx->set_cancel(f);
}
@ -279,11 +278,6 @@ public:
}
}
protected:
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
};

View file

@ -256,12 +256,6 @@ unsigned model_evaluator::get_num_steps() const {
return m_imp->get_num_steps();
}
void model_evaluator::set_cancel(bool f) {
#pragma omp critical (model_evaluator)
{
m_imp->set_cancel(f);
}
}
void model_evaluator::cleanup(params_ref const & p) {
model & md = m_imp->cfg().m_model;

View file

@ -41,9 +41,6 @@ public:
void operator()(expr * t, expr_ref & r);
void set_cancel(bool f);
void cancel() { set_cancel(true); }
void reset_cancel() { set_cancel(false); }
void cleanup(params_ref const & p = params_ref());
void reset(params_ref const & p = params_ref());

View file

@ -63,9 +63,6 @@ class horn_tactic : public tactic {
m_ctx.collect_statistics(st);
}
void set_cancel(bool f) {
}
void normalize(expr_ref& f) {
bool is_positive = true;
expr* e = 0;
@ -420,11 +417,7 @@ public:
}
}
protected:
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
};
tactic * mk_horn_tactic(ast_manager & m, params_ref const & p) {

View file

@ -141,7 +141,6 @@ namespace nlsat {
svector<trail> m_trail;
anum m_zero;
bool m_cancel;
// configuration
unsigned long long m_max_memory;
@ -164,7 +163,7 @@ namespace nlsat {
m_solver(s),
m_rlimit(rlim),
m_allocator("nlsat"),
m_pm(m_qm, &m_allocator),
m_pm(rlim, m_qm, &m_allocator),
m_cache(m_pm),
m_am(rlim, m_qm, p, &m_allocator),
m_asm(*this, m_allocator),
@ -180,7 +179,6 @@ namespace nlsat {
m_lemma_assumptions(m_asm) {
updt_params(p);
reset_statistics();
m_cancel = false;
mk_true_bvar();
}
@ -218,15 +216,11 @@ namespace nlsat {
m_am.updt_params(p.p);
}
void set_cancel(bool f) {
m_pm.set_cancel(f);
m_am.set_cancel(f);
m_cancel = f;
}
void checkpoint() {
if (m_cancel) throw solver_exception(Z3_CANCELED_MSG);
if (!m_rlimit.inc()) throw solver_exception(Z3_MAX_RESOURCE_MSG);
if (!m_rlimit.inc()) {
if (m_rlimit.cancel_flag_set()) throw solver_exception(Z3_CANCELED_MSG);
throw solver_exception(Z3_MAX_RESOURCE_MSG);
}
if (memory::get_allocation_size() > m_max_memory) throw solver_exception(Z3_MAX_MEMORY_MSG);
}
@ -2571,10 +2565,6 @@ namespace nlsat {
return m_imp->check();
}
void solver::set_cancel(bool f) {
m_imp->set_cancel(f);
}
void solver::collect_param_descrs(param_descrs & d) {
algebraic_numbers::manager::collect_param_descrs(d);
nlsat_params::collect_param_descrs(d);

View file

@ -154,7 +154,6 @@ namespace nlsat {
void updt_params(params_ref const & p);
static void collect_param_descrs(param_descrs & d);
void set_cancel(bool f);
void collect_statistics(statistics & st);
void reset_statistics();
void display_status(std::ostream & out) const;

View file

@ -61,7 +61,6 @@ struct goal2nlsat::imp {
unsigned long long m_max_memory;
bool m_factor;
volatile bool m_cancel;
imp(ast_manager & _m, params_ref const & p, nlsat::solver & s, expr2var & a2b, expr2var & t2x):
m(_m),
@ -73,7 +72,6 @@ struct goal2nlsat::imp {
m_t2x(t2x),
m_expr2poly(m_solver, m, m_solver.pm(), &m_t2x) {
updt_params(p);
m_cancel = false;
}
void updt_params(params_ref const & p) {
@ -82,11 +80,6 @@ struct goal2nlsat::imp {
m_fparams.updt_params(p);
}
void set_cancel(bool f) {
m_cancel = f;
m_pm.set_cancel(f);
}
nlsat::atom::kind flip(nlsat::atom::kind k) {
switch (k) {
case nlsat::atom::EQ: return k;
@ -303,7 +296,3 @@ void goal2nlsat::operator()(goal const & g, params_ref const & p, nlsat::solver
local_imp(g);
}
void goal2nlsat::set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}

View file

@ -51,7 +51,6 @@ public:
*/
void operator()(goal const & g, params_ref const & p, nlsat::solver & s, expr2var & a2b, expr2var & t2x);
void set_cancel(bool f);
};
class nlsat2goal {
@ -69,7 +68,6 @@ public:
void operator()(nlsat::solver const & s, expr2var const & a2b, expr2var const & t2x,
params_ref const & p, goal & g, model_converter_ref & mc);
void set_cancel(bool f);
};
#endif

View file

@ -57,11 +57,6 @@ class nlsat_tactic : public tactic {
m_params = p;
m_solver.updt_params(p);
}
void set_cancel(bool f) {
m_solver.set_cancel(f);
m_g2nl.set_cancel(f);
}
bool contains_unsupported(expr_ref_vector & b2a, expr_ref_vector & x2t) {
for (unsigned x = 0; x < x2t.size(); x++) {
@ -240,11 +235,6 @@ public:
virtual void cleanup() {}
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
virtual void collect_statistics(statistics & st) const {
st.copy(m_stats);
}

View file

@ -33,25 +33,20 @@ struct mus::imp {
ast_manager& m;
expr_ref_vector m_cls2expr;
obj_map<expr, unsigned> m_expr2cls;
volatile bool m_cancel;
model_ref m_model;
expr_ref_vector m_soft;
vector<rational> m_weights;
rational m_weight;
imp(solver& s, ast_manager& m):
m_s(s), m(m), m_cls2expr(m), m_cancel(false), m_soft(m)
m_s(s), m(m), m_cls2expr(m), m_soft(m)
{}
void reset() {
m_cls2expr.reset();
m_expr2cls.reset();
}
void set_cancel(bool f) {
m_cancel = f;
}
unsigned add_soft(expr* cls) {
SASSERT(is_uninterp_const(cls) ||
@ -216,9 +211,6 @@ lbool mus::get_mus(unsigned_vector& mus) {
return m_imp->get_mus(mus);
}
void mus::set_cancel(bool f) {
m_imp->set_cancel(f);
}
void mus::reset() {
m_imp->reset();

View file

@ -39,8 +39,6 @@ namespace opt {
void reset();
void set_cancel(bool f);
/**
Instrument MUS extraction to also provide the minimal
penalty model, if any is found.

View file

@ -195,7 +195,7 @@ public:
opt.add_hard_constraint(*it);
}
lbool r = l_undef;
cancel_eh<opt::context> eh(opt);
cancel_eh<reslimit> eh(m.limit());
{
scoped_ctrl_c ctrlc(eh);
scoped_timer timer(timeout, &eh);

View file

@ -297,11 +297,7 @@ namespace opt {
m_context.get_relevant_labels(0, tmp);
r.append(tmp.size(), tmp.c_ptr());
}
void opt_solver::set_cancel(bool f) {
m_context.set_cancel(f);
}
void opt_solver::set_progress_callback(progress_callback * callback) {
m_callback = callback;
m_context.set_progress_callback(callback);

View file

@ -100,11 +100,11 @@ namespace opt {
virtual proof * get_proof();
virtual std::string reason_unknown() const;
virtual void get_labels(svector<symbol> & r);
virtual void set_cancel(bool f);
virtual void set_progress_callback(progress_callback * callback);
virtual unsigned get_num_assertions() const;
virtual expr * get_assertion(unsigned idx) const;
virtual void display(std::ostream & out) const;
virtual ast_manager& get_manager() { return m; }
void set_logic(symbol const& logic);
smt::theory_var add_objective(app* term);

View file

@ -84,7 +84,7 @@ namespace sat {
tout << "core: " << core << "\n";
tout << "mus: " << mus << "\n";);
if (s.m_cancel) {
if (s.canceled()) {
set_core();
return l_undef;
}

View file

@ -50,7 +50,7 @@ namespace sat {
return m_elems[rnd(num_elems())];
}
sls::sls(solver& s): s(s), m_cancel(false) {
sls::sls(solver& s): s(s) {
m_prob_choose_min_var = 43;
m_clause_generation = 0;
}
@ -64,7 +64,7 @@ namespace sat {
lbool sls::operator()(unsigned sz, literal const* tabu, bool reuse_model) {
init(sz, tabu, reuse_model);
unsigned i;
for (i = 0; !m_false.empty() && !m_cancel && i < m_max_tries; ++i) {
for (i = 0; !m_false.empty() && !s.canceled() && i < m_max_tries; ++i) {
flip();
}
IF_VERBOSE(2, verbose_stream() << "tries " << i << "\n";);
@ -378,7 +378,7 @@ namespace sat {
}
DEBUG_CODE(check_invariant(););
unsigned i = 0;
for (; !m_cancel && m_best_value > 0 && i < m_max_tries; ++i) {
for (; !s.canceled() && m_best_value > 0 && i < m_max_tries; ++i) {
wflip();
if (m_false.empty()) {
double val = evaluate_model(m_model);

View file

@ -54,12 +54,10 @@ namespace sat {
clause_allocator m_alloc; // clause allocator
clause_vector m_bin_clauses; // binary clauses
svector<bool> m_tabu; // variables that cannot be swapped
volatile bool m_cancel;
public:
sls(solver& s);
virtual ~sls();
lbool operator()(unsigned sz, literal const* tabu, bool reuse_model);
void set_cancel(bool f) { m_cancel = f; }
void set_max_tries(unsigned mx) { m_max_tries = mx; }
virtual void display(std::ostream& out) const;
protected:

View file

@ -32,7 +32,6 @@ Revision History:
namespace sat {
solver::solver(params_ref const & p, reslimit& l, extension * ext):
m_cancel(false),
m_rlimit(l),
m_config(p),
m_ext(ext),
@ -2714,11 +2713,6 @@ namespace sat {
scc::collect_param_descrs(d);
}
void solver::set_cancel(bool f) {
m_cancel = f;
m_wsls.set_cancel(f);
}
void solver::collect_statistics(statistics & st) const {
m_stats.collect_statistics(st);
m_cleaner.collect_statistics(st);
@ -2784,7 +2778,7 @@ namespace sat {
//
// -----------------------
bool solver::check_invariant() const {
if (m_cancel) return true;
if (!m_rlimit.inc()) return true;
integrity_checker checker(*this);
SASSERT(checker());
return true;

View file

@ -71,7 +71,6 @@ namespace sat {
public:
struct abort_solver {};
protected:
volatile bool m_cancel;
reslimit& m_rlimit;
config m_config;
stats m_stats;
@ -158,7 +157,6 @@ namespace sat {
void updt_params(params_ref const & p);
static void collect_param_descrs(param_descrs & d);
void set_cancel(bool f);
void collect_statistics(statistics & st) const;
void reset_statistics();
void display_status(std::ostream & out) const;
@ -239,13 +237,13 @@ namespace sat {
lbool status(clause const & c) const;
clause_offset get_offset(clause const & c) const { return m_cls_allocator.get_offset(&c); }
void checkpoint() {
if (m_cancel) throw solver_exception(Z3_CANCELED_MSG);
if (!m_rlimit.inc()) { m_cancel = true; throw solver_exception(Z3_CANCELED_MSG); }
if (!m_rlimit.inc()) { throw solver_exception(Z3_CANCELED_MSG); }
++m_num_checkpoints;
if (m_num_checkpoints < 10) return;
m_num_checkpoints = 0;
if (memory::get_allocation_size() > m_config.m_max_memory) throw solver_exception(Z3_MAX_MEMORY_MSG);
}
bool canceled() { return !m_rlimit.inc(); }
typedef std::pair<literal, literal> bin_clause;
protected:
watch_list & get_wlist(literal l) { return m_watches[l.index()]; }

View file

@ -85,7 +85,6 @@ public:
simp2_p.set_bool("flat", true); // required by som
simp2_p.set_bool("hoist_mul", false); // required by som
simp2_p.set_bool("elim_and", true);
m_preprocess =
and_then(mk_card2bv_tactic(m, m_params),
using_params(mk_simplify_tactic(m), simp2_p),
@ -169,11 +168,6 @@ public:
}
return r;
}
virtual void set_cancel(bool f) {
m_goal2sat.set_cancel(f);
m_solver.set_cancel(f);
if (f) m_preprocess->cancel(); else m_preprocess->reset_cancel();
}
virtual void push() {
internalize_formulas();
m_solver.user_push();
@ -215,6 +209,7 @@ public:
assert_expr(t);
}
}
virtual ast_manager& get_manager() { return m; }
virtual void assert_expr(expr * t) {
TRACE("sat", tout << mk_pp(t, m) << "\n";);
m_fmls.push_back(t);

View file

@ -58,7 +58,6 @@ struct goal2sat::imp {
sat::bool_var m_true;
bool m_ite_extra;
unsigned long long m_max_memory;
volatile bool m_cancel;
expr_ref_vector m_trail;
bool m_default_external;
@ -70,7 +69,6 @@ struct goal2sat::imp {
m_trail(m),
m_default_external(default_external) {
updt_params(p);
m_cancel = false;
m_true = sat::null_bool_var;
}
@ -334,7 +332,7 @@ struct goal2sat::imp {
while (!m_frame_stack.empty()) {
loop:
cooperate("goal2sat");
if (m_cancel)
if (m.canceled())
throw tactic_exception(TACTIC_CANCELED_MSG);
if (memory::get_allocation_size() > m_max_memory)
throw tactic_exception(TACTIC_MAX_MEMORY_MSG);
@ -442,7 +440,6 @@ struct goal2sat::imp {
process(fs[i]);
}
void set_cancel(bool f) { m_cancel = f; }
};
struct unsupported_bool_proc {
@ -507,14 +504,6 @@ void goal2sat::operator()(goal const & g, params_ref const & p, sat::solver & t,
proc(g);
}
void goal2sat::set_cancel(bool f) {
#pragma omp critical (goal2sat)
{
if (m_imp)
m_imp->set_cancel(f);
}
}
struct sat2goal::imp {
@ -631,9 +620,8 @@ struct sat2goal::imp {
expr_ref_vector m_lit2expr;
unsigned long long m_max_memory;
bool m_learned;
volatile bool m_cancel;
imp(ast_manager & _m, params_ref const & p):m(_m), m_lit2expr(m), m_cancel(false) {
imp(ast_manager & _m, params_ref const & p):m(_m), m_lit2expr(m) {
updt_params(p);
}
@ -643,7 +631,7 @@ struct sat2goal::imp {
}
void checkpoint() {
if (m_cancel)
if (m.canceled())
throw tactic_exception(TACTIC_CANCELED_MSG);
if (memory::get_allocation_size() > m_max_memory)
throw tactic_exception(TACTIC_MAX_MEMORY_MSG);
@ -731,7 +719,6 @@ struct sat2goal::imp {
assert_clauses(s.begin_learned(), s.end_learned(), r);
}
void set_cancel(bool f) { m_cancel = f; }
};
sat2goal::sat2goal():m_imp(0) {
@ -765,10 +752,3 @@ void sat2goal::operator()(sat::solver const & t, atom2bool_var const & m, params
proc(t, m, g, mc);
}
void sat2goal::set_cancel(bool f) {
#pragma omp critical (sat2goal)
{
if (m_imp)
m_imp->set_cancel(f);
}
}

View file

@ -59,7 +59,6 @@ public:
*/
void operator()(goal const & g, params_ref const & p, sat::solver & t, atom2bool_var & m, dep2asm_map& dep2asm, bool default_external = false);
void set_cancel(bool f);
};
@ -83,7 +82,6 @@ public:
*/
void operator()(sat::solver const & t, atom2bool_var const & m, params_ref const & p, goal & s, model_converter_ref & mc);
void set_cancel(bool f);
};
#endif

View file

@ -123,11 +123,6 @@ class sat_tactic : public tactic {
result.push_back(g.get());
}
void set_cancel(bool f) {
m_goal2sat.set_cancel(f);
m_sat2goal.set_cancel(f);
m_solver.set_cancel(f);
}
void dep2assumptions(obj_map<expr, sat::literal>& dep2asm,
sat::literal_vector& assumptions) {
@ -223,13 +218,6 @@ public:
}
protected:
virtual void set_cancel(bool f) {
#pragma omp critical (sat_tactic)
{
if (m_imp)
m_imp->set_cancel(f);
}
}
};

View file

@ -54,8 +54,7 @@ asserted_formulas::asserted_formulas(ast_manager & m, smt_params & p):
m_macro_manager(m, m_simplifier),
m_bit2int(m),
m_bv_sharing(m),
m_inconsistent(false),
m_cancel_flag(false) {
m_inconsistent(false){
m_bsimp = 0;
m_bvsimp = 0;
@ -223,9 +222,6 @@ void asserted_formulas::reset() {
m_inconsistent = false;
}
void asserted_formulas::set_cancel_flag(bool f) {
m_cancel_flag = f;
}
#ifdef Z3DEBUG
bool asserted_formulas::check_well_sorted() const {

View file

@ -62,7 +62,6 @@ class asserted_formulas {
bool m_inconsistent_old;
};
svector<scope> m_scopes;
volatile bool m_cancel_flag;
void setup_simplifier_plugins(simplifier & s, basic_simplifier_plugin * & bsimp, arith_simplifier_plugin * & asimp, bv_simplifier_plugin * & bvsimp);
void reduce_asserted_formulas();
@ -97,7 +96,7 @@ class asserted_formulas {
unsigned get_total_size() const;
bool has_bv() const;
void max_bv_sharing();
bool canceled() { return m_cancel_flag; }
bool canceled() { return m_manager.canceled(); }
public:
asserted_formulas(ast_manager & m, smt_params & p);

View file

@ -77,7 +77,6 @@ public:
void collect_statistics(statistics & st) const { m_solver.collect_statistics(st); }
void reset_statistics() { m_solver.reset_statistics(); }
void set_cancel(bool f) { m_solver.set_cancel(f); }
};
#endif /* EXPR_CONTEXT_SIMPLIFIER_H_ */

View file

@ -45,7 +45,6 @@ namespace smt {
m_fparams(p),
m_params(_p),
m_setup(*this, p),
m_cancel_flag(false),
m_asserted_formulas(m, p),
m_qmanager(alloc(quantifier_manager, *this, p, _p)),
m_model_generator(alloc(model_generator, m)),
@ -3069,11 +3068,6 @@ namespace smt {
if (m_manager.has_trace_stream())
m_manager.trace_stream() << "[begin-check] " << m_scope_lvl << "\n";
if (reset_cancel) {
m_cancel_flag = false;
m_asserted_formulas.set_cancel_flag(false);
}
if (memory::above_high_watermark()) {
m_last_search_failure = MEMOUT;
return false;
@ -4154,11 +4148,6 @@ namespace smt {
return m_last_search_failure;
}
void context::set_cancel_flag(bool f) {
m_cancel_flag = f;
m_asserted_formulas.set_cancel_flag(f);
}
};
#ifdef Z3DEBUG

View file

@ -79,7 +79,6 @@ namespace smt {
smt_params & m_fparams;
params_ref m_params;
setup m_setup;
volatile bool m_cancel_flag;
timer m_timer;
asserted_formulas m_asserted_formulas;
scoped_ptr<quantifier_manager> m_qmanager;
@ -233,9 +232,8 @@ namespace smt {
return m_params;
}
virtual void set_cancel_flag(bool f = true);
bool get_cancel_flag() { return m_cancel_flag || !m_manager.limit().inc(); }
bool get_cancel_flag() { return !m_manager.limit().inc(); }
region & get_region() {
return m_region;

View file

@ -169,10 +169,6 @@ namespace smt {
void display_istatistics(std::ostream & out) const {
m_kernel.display_istatistics(out);
}
void set_cancel(bool f) {
m_kernel.set_cancel_flag(f);
}
bool canceled() {
return m_kernel.get_cancel_flag();
@ -328,14 +324,6 @@ namespace smt {
m_imp->display_istatistics(out);
}
void kernel::set_cancel(bool f) {
#pragma omp critical (smt_kernel)
{
if (m_imp)
m_imp->set_cancel(f);
}
}
bool kernel::canceled() const {
return m_imp->canceled();
}

View file

@ -204,18 +204,7 @@ namespace smt {
\brief Display statistics in low level format.
*/
void display_istatistics(std::ostream & out) const;
/**
\brief Interrupt the kernel.
*/
void set_cancel(bool f = true);
void cancel() { set_cancel(true); }
/**
\brief Reset interruption.
*/
void reset_cancel() { set_cancel(false); }
/**
\brief Return true if the kernel was interrupted.
*/

View file

@ -101,9 +101,8 @@ namespace smt {
r.append(tmp.size(), tmp.c_ptr());
}
virtual void set_cancel(bool f) {
m_context.set_cancel(f);
}
virtual ast_manager& get_manager() { return m_context.m(); }
virtual void set_progress_callback(progress_callback * callback) {
m_callback = callback;

View file

@ -35,12 +35,10 @@ class ctx_solver_simplify_tactic : public tactic {
func_decl_ref m_fn;
obj_map<sort, func_decl*> m_fns;
unsigned m_num_steps;
volatile bool m_cancel;
public:
ctx_solver_simplify_tactic(ast_manager & m, params_ref const & p = params_ref()):
m(m), m_params(p), m_solver(m, m_front_p),
m_arith(m), m_mk_app(m), m_fn(m), m_num_steps(0),
m_cancel(false) {
m_arith(m), m_mk_app(m), m_fn(m), m_num_steps(0) {
sort* i_sort = m_arith.mk_int();
m_fn = m.mk_func_decl(symbol(0xbeef101), i_sort, m.mk_bool_sort());
}
@ -86,15 +84,10 @@ public:
virtual void cleanup() {
reset_statistics();
m_solver.reset();
m_cancel = false;
}
protected:
virtual void set_cancel(bool f) {
m_solver.set_cancel(f);
m_cancel = false;
}
void reduce(goal& g) {
SASSERT(g.is_well_sorted());
@ -177,7 +170,7 @@ protected:
names.push_back(n);
m_solver.push();
while (!todo.empty() && !m_cancel) {
while (!todo.empty() && !m.canceled()) {
expr_ref res(m);
args.reset();
expr* e = todo.back().m_expr;
@ -249,7 +242,7 @@ protected:
names.pop_back();
m_solver.pop(1);
}
if (!m_cancel) {
if (!m.canceled()) {
VERIFY(cache.find(fml, path_r));
result = path_r.m_expr;
}

View file

@ -132,10 +132,6 @@ public:
smt_params_helper::collect_param_descrs(r);
}
virtual void set_cancel(bool f) {
if (m_ctx)
m_ctx->set_cancel(f);
}
virtual void collect_statistics(statistics & st) const {
if (m_ctx)

View file

@ -22,7 +22,6 @@ struct unit_subsumption_tactic : public tactic {
ast_manager& m;
params_ref m_params;
smt_params m_fparams;
volatile bool m_cancel;
smt::context m_context;
expr_ref_vector m_clauses;
unsigned m_clause_count;
@ -34,19 +33,11 @@ struct unit_subsumption_tactic : public tactic {
params_ref const& p):
m(m),
m_params(p),
m_cancel(false),
m_context(m, m_fparams, p),
m_clauses(m) {
}
void set_cancel(bool f) {
m_cancel = f;
m_context.set_cancel_flag(f);
}
virtual void cleanup() {
set_cancel(false);
}
void cleanup() {}
virtual void operator()(/* in */ goal_ref const & in,
/* out */ goal_ref_buffer & result,
@ -66,7 +57,7 @@ struct unit_subsumption_tactic : public tactic {
}
void checkpoint() {
if (m_cancel) {
if (m.canceled()) {
throw tactic_exception(TACTIC_CANCELED_MSG);
}
}

View file

@ -52,6 +52,7 @@ public:
virtual proof * get_proof() = 0;
virtual std::string reason_unknown() const = 0;
virtual void get_labels(svector<symbol> & r) = 0;
virtual ast_manager& get_manager() = 0;
};
/**
@ -63,9 +64,11 @@ struct simple_check_sat_result : public check_sat_result {
expr_ref_vector m_core;
proof_ref m_proof;
std::string m_unknown;
simple_check_sat_result(ast_manager & m);
virtual ~simple_check_sat_result();
virtual ast_manager& get_manager() { return m_proof.get_manager(); }
virtual void collect_statistics(statistics & st) const;
virtual void get_unsat_core(ptr_vector<expr> & r);
virtual void get_model(model_ref & m);

View file

@ -84,7 +84,7 @@ private:
volatile bool m_canceled;
aux_timeout_eh(solver * s):m_solver(s), m_canceled(false) {}
virtual void operator()() {
m_solver->cancel();
m_solver->get_manager().cancel();
m_canceled = true;
}
};
@ -96,6 +96,8 @@ private:
m_inc_unknown_behavior = static_cast<inc_unknown_behavior>(p.solver2_unknown());
}
virtual ast_manager& get_manager() { return m_solver1->get_manager(); }
bool has_quantifiers() const {
unsigned sz = get_num_assertions();
for (unsigned i = 0; i < sz; i++) {
@ -220,25 +222,18 @@ public:
m_use_solver1_results = false;
return r;
}
if (eh.m_canceled) {
m_solver1->get_manager().limit().reset_cancel();
}
}
IF_VERBOSE(PS_VB_LVL, verbose_stream() << "(combined-solver \"solver 2 failed, trying solver1\")\n";);
IF_VERBOSE(PS_VB_LVL, verbose_stream() << "(combined-solver \"solver 2 failed, trying solver1\")\n";);
}
IF_VERBOSE(PS_VB_LVL, verbose_stream() << "(combined-solver \"using solver 1\")\n";);
m_use_solver1_results = true;
return m_solver1->check_sat(0, 0);
}
virtual void set_cancel(bool f) {
if (f) {
m_solver1->cancel();
m_solver2->cancel();
}
else {
m_solver1->reset_cancel();
m_solver2->reset_cancel();
}
}
virtual void set_progress_callback(progress_callback * callback) {
m_solver1->set_progress_callback(callback);

View file

@ -108,11 +108,11 @@ public:
/**
\brief Interrupt this solver.
*/
void cancel() { set_cancel(true); }
//void cancel() { set_cancel(true); }
/**
\brief Reset the interruption.
*/
void reset_cancel() { set_cancel(false); }
//void reset_cancel() { set_cancel(false); }
/**
\brief Set a progress callback procedure that is invoked by this solver during check_sat.
@ -158,7 +158,7 @@ public:
};
protected:
virtual void set_cancel(bool f) = 0;
//virtual void set_cancel(bool f) = 0;
};
#endif

View file

@ -59,7 +59,6 @@ public:
virtual void pop_core(unsigned n);
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions);
virtual void set_cancel(bool f);
virtual void collect_statistics(statistics & st) const;
virtual void get_unsat_core(ptr_vector<expr> & r);
@ -74,8 +73,11 @@ public:
virtual expr * get_assertion(unsigned idx) const;
virtual void display(std::ostream & out) const;
virtual ast_manager& get_manager();
};
ast_manager& tactic2solver::get_manager() { return m_assertions.get_manager(); }
tactic2solver::tactic2solver(ast_manager & m, tactic * t, params_ref const & p, bool produce_proofs, bool produce_models, bool produce_unsat_cores, symbol const & logic):
solver_na2as(m),
m_assertions(m) {
@ -177,14 +179,6 @@ lbool tactic2solver::check_sat_core(unsigned num_assumptions, expr * const * ass
return m_result->status();
}
void tactic2solver::set_cancel(bool f) {
if (m_tactic.get()) {
if (f)
m_tactic->cancel();
else
m_tactic->reset_cancel();
}
}
solver* tactic2solver::translate(ast_manager& m, params_ref const& p) {
tactic* t = m_tactic->translate(m);

View file

@ -37,6 +37,7 @@ solver * mk_tactic2solver(ast_manager & m,
bool produce_unsat_cores = false,
symbol const & logic = symbol::null);
solver_factory * mk_tactic2solver_factory(tactic * t);
solver_factory * mk_tactic_factory2solver_factory(tactic_factory * f);

View file

@ -119,7 +119,6 @@ struct aig_manager::imp {
aig_lit m_false;
bool m_default_gate_encoding;
unsigned long long m_max_memory;
volatile bool m_cancel;
void dec_ref_core(aig * n) {
SASSERT(n->m_ref_count > 0);
@ -131,7 +130,7 @@ struct aig_manager::imp {
void checkpoint() {
if (memory::get_allocation_size() > m_max_memory)
throw aig_exception(TACTIC_MAX_MEMORY_MSG);
if (m_cancel)
if (m().canceled())
throw aig_exception(TACTIC_CANCELED_MSG);
cooperate("aig");
}
@ -1309,8 +1308,7 @@ public:
m_num_aigs(0),
m_var2exprs(m),
m_allocator("aig"),
m_true(mk_var(m.mk_true())),
m_cancel(false) {
m_true(mk_var(m.mk_true())) {
SASSERT(is_true(m_true));
m_false = m_true;
m_false.invert();
@ -1328,7 +1326,6 @@ public:
ast_manager & m() const { return m_var2exprs.get_manager(); }
void set_cancel(bool f) { m_cancel = f; }
void inc_ref(aig * n) { n->m_ref_count++; }
void inc_ref(aig_lit const & r) { inc_ref(r.ptr()); }
@ -1754,8 +1751,5 @@ unsigned aig_manager::get_num_aigs() const {
return m_imp->get_num_aigs();
}
void aig_manager::set_cancel(bool f) {
m_imp->set_cancel(f);
}

View file

@ -73,7 +73,6 @@ public:
void display(std::ostream & out, aig_ref const & r) const;
void display_smt2(std::ostream & out, aig_ref const & r) const;
unsigned get_num_aigs() const;
void set_cancel(bool f);
};
#endif

View file

@ -111,14 +111,6 @@ public:
virtual void cleanup() {}
protected:
virtual void set_cancel(bool f) {
#pragma omp critical (aig_tactic)
{
if (m_aig_manager)
m_aig_manager->set_cancel(f);
}
}
};
tactic * mk_aig_tactic(params_ref const & p) {

View file

@ -62,7 +62,6 @@ class add_bounds_tactic : public tactic {
ast_manager & m;
rational m_lower;
rational m_upper;
volatile bool m_cancel;
imp(ast_manager & _m, params_ref const & p):
m(_m) {
@ -74,9 +73,6 @@ class add_bounds_tactic : public tactic {
m_upper = p.get_rat("add_bound_upper", rational(2));
}
void set_cancel(bool f) {
m_cancel = f;
}
struct add_bound_proc {
arith_util m_util;
@ -180,11 +176,6 @@ public:
dealloc(d);
}
protected:
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
};
tactic * mk_add_bounds_tactic(ast_manager & m, params_ref const & p) {

View file

@ -13,24 +13,15 @@ struct arith_bounds_tactic : public tactic {
ast_manager& m;
arith_util a;
volatile bool m_cancel;
arith_bounds_tactic(ast_manager& m):
m(m),
a(m),
m_cancel(false)
a(m)
{
}
ast_manager& get_manager() { return m; }
void set_cancel(bool f) {
m_cancel = f;
}
virtual void cleanup() {
m_cancel = false;
}
virtual void operator()(/* in */ goal_ref const & in,
/* out */ goal_ref_buffer & result,
@ -45,7 +36,7 @@ struct arith_bounds_tactic : public tactic {
}
void checkpoint() {
if (m_cancel) {
if (m.canceled()) {
throw tactic_exception(TACTIC_CANCELED_MSG);
}
}
@ -155,6 +146,7 @@ struct arith_bounds_tactic : public tactic {
TRACE("arith_subsumption", s->display(tout); );
}
virtual void cleanup() {}
};

View file

@ -462,10 +462,6 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
}
void set_cancel(bool f) {
m_rw1.set_cancel(f);
m_rw2.set_cancel(f);
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,

View file

@ -40,7 +40,6 @@ class degree_shift_tactic : public tactic {
rational m_one;
bool m_produce_models;
bool m_produce_proofs;
volatile bool m_cancel;
expr * mk_power(expr * t, rational const & k) {
if (k.is_one())
@ -96,15 +95,11 @@ class degree_shift_tactic : public tactic {
m_pinned(_m),
m_one(1),
m_rw(0) {
m_cancel = false;
}
void set_cancel(bool f) {
m_cancel = f;
}
void checkpoint() {
if (m_cancel)
if (m.canceled())
throw tactic_exception(TACTIC_CANCELED_MSG);
cooperate("degree_shift");
}
@ -326,12 +321,7 @@ public:
}
dealloc(d);
}
protected:
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
};
tactic * mk_degree_shift_tactic(ast_manager & m, params_ref const & p) {

View file

@ -45,7 +45,6 @@ class diff_neq_tactic : public tactic {
vector<diseqs> m_var_diseqs;
typedef svector<int> decision_stack;
decision_stack m_stack;
volatile bool m_cancel;
bool m_produce_models;
rational m_max_k;
@ -58,7 +57,6 @@ class diff_neq_tactic : public tactic {
u(m),
m_var2expr(m) {
updt_params(p);
m_cancel = false;
}
void updt_params(params_ref const & p) {
@ -67,11 +65,7 @@ class diff_neq_tactic : public tactic {
if (m_max_k >= rational(INT_MAX/2))
m_max_k = rational(INT_MAX/2);
}
void set_cancel(bool f) {
m_cancel = f;
}
void throw_not_supported() {
throw tactic_exception("goal is not diff neq");
}
@ -294,7 +288,7 @@ class diff_neq_tactic : public tactic {
init_forbidden();
unsigned nvars = num_vars();
while (m_stack.size() < nvars) {
if (m_cancel)
if (m.canceled())
throw tactic_exception(TACTIC_CANCELED_MSG);
TRACE("diff_neq_tactic", display_model(tout););
var x = m_stack.size();
@ -407,11 +401,6 @@ public:
dealloc(d);
}
protected:
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
};
tactic * mk_diff_neq_tactic(ast_manager & m, params_ref const & p) {

View file

@ -136,10 +136,7 @@ public:
virtual ~elim01_tactic() {
}
void set_cancel(bool f) {
}
virtual void updt_params(params_ref const & p) {
m_max_hi = rational(p.get_uint("max_coefficient", m_max_hi_default));
m_params = p;

View file

@ -139,9 +139,6 @@ public:
virtual ~eq2bv_tactic() {
}
void set_cancel(bool f) {
m_rw.set_cancel(f);
}
void updt_params(params_ref const & p) {
}

View file

@ -34,7 +34,7 @@ class factor_tactic : public tactic {
rw_cfg(ast_manager & _m, params_ref const & p):
m(_m),
m_util(_m),
m_pm(m_qm),
m_pm(m.limit(), m_qm),
m_expr2poly(m, m_pm) {
updt_params(p);
}
@ -251,10 +251,6 @@ class factor_tactic : public tactic {
m_rw(m, p) {
}
void set_cancel(bool f) {
m_rw.set_cancel(f);
m_rw.cfg().m_pm.set_cancel(f);
}
void updt_params(params_ref const & p) {
m_rw.cfg().updt_params(p);
@ -341,10 +337,7 @@ public:
dealloc(d);
}
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
};
tactic * mk_factor_tactic(ast_manager & m, params_ref const & p) {

View file

@ -247,11 +247,7 @@ class fix_dl_var_tactic : public tactic {
void updt_params(params_ref const & p) {
m_rw.updt_params(p);
}
void set_cancel(bool f) {
m_rw.set_cancel(f);
}
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
@ -345,11 +341,6 @@ public:
}
dealloc(d);
}
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
};
tactic * mk_fix_dl_var_tactic(ast_manager & m, params_ref const & p) {

View file

@ -44,7 +44,6 @@ class fm_tactic : public tactic {
ast_manager & m;
ptr_vector<func_decl> m_xs;
vector<clauses> m_clauses;
volatile bool m_cancel;
enum r_kind {
NONE,
@ -182,7 +181,6 @@ class fm_tactic : public tactic {
virtual void operator()(model_ref & md, unsigned goal_idx) {
TRACE("fm_mc", model_v2_pp(tout, *md); display(tout););
m_cancel = false;
model_evaluator ev(*(md.get()));
ev.set_model_completion(true);
arith_util u(m);
@ -199,7 +197,7 @@ class fm_tactic : public tactic {
clauses::iterator it = m_clauses[i].begin();
clauses::iterator end = m_clauses[i].end();
for (; it != end; ++it) {
if (m_cancel) throw tactic_exception(TACTIC_CANCELED_MSG);
if (m.canceled()) throw tactic_exception(TACTIC_CANCELED_MSG);
switch (process(x, *it, u, ev, val)) {
case NONE:
TRACE("fm_mc", tout << "no bound for:\n" << mk_ismt2_pp(*it, m) << "\n";);
@ -244,9 +242,6 @@ class fm_tactic : public tactic {
TRACE("fm_mc", model_v2_pp(tout, *md););
}
virtual void cancel() {
m_cancel = true;
}
virtual void display(std::ostream & out) {
out << "(fm-model-converter";
@ -394,7 +389,6 @@ class fm_tactic : public tactic {
obj_hashtable<func_decl> m_forbidden_set; // variables that cannot be eliminated because occur in non OCC ineq part
goal_ref m_new_goal;
ref<fm_model_converter> m_mc;
volatile bool m_cancel;
id_gen m_id_gen;
bool m_produce_models;
bool m_fm_real_only;
@ -784,7 +778,6 @@ class fm_tactic : public tactic {
m_var2expr(m),
m_inconsistent_core(m) {
updt_params(p);
m_cancel = false;
}
~imp() {
@ -801,9 +794,6 @@ class fm_tactic : public tactic {
m_fm_occ = p.get_bool("fm_occ", false);
}
void set_cancel(bool f) {
m_cancel = f;
}
struct forbidden_proc {
imp & m_owner;
@ -1552,7 +1542,7 @@ class fm_tactic : public tactic {
void checkpoint() {
cooperate("fm");
if (m_cancel)
if (m.canceled())
throw tactic_exception(TACTIC_CANCELED_MSG);
if (memory::get_allocation_size() > m_max_memory)
throw tactic_exception(TACTIC_MAX_MEMORY_MSG);
@ -1676,10 +1666,6 @@ public:
r.insert("fm_extra", CPK_UINT, "(default: 0) max. increase on the number of inequalities for each FM variable elimination step.");
}
virtual void set_cancel(bool f) {
if (m_imp)
m_imp->set_cancel(f);
}
virtual void cleanup() {
imp * d = alloc(imp, m_imp->m, m_params);

Some files were not shown because too many files have changed in this diff Show more