void contractor_pseq::init() {
DREAL_LOG_DEBUG << "contractor_pseq::prune";
auto const num_thread = min(thread::hardware_concurrency(), static_cast<unsigned>(m_vec.size()));
cerr << m_vec.size() << " constraints\t"
<< num_thread << " threads" << endl;
if (m_vec.size() < num_thread) {
m_ctc = mk_contractor_seq(m_vec);
m_use_threads = false;
return;
}
vector<vector<contractor>> vv(num_thread);
vector<contractor> v(num_thread);
for (unsigned i = 0; i < m_vec.size(); i++) {
vv[i % num_thread].push_back(m_vec[i]);
}
for (unsigned i = 0; i < num_thread; i++) {
cerr << "vv[" << i << "].size() = "
<< vv[i].size() << endl;
v[i] = mk_contractor_seq(vv[i]);
}
m_ctc = mk_contractor_parallel_all(v);
m_use_threads = true;
}
contractor make_contractor(Enode * e,
lbool const
polarity,
box const & b,
unordered_set<Enode *> const & var_set) {
if (e->isNot()) {
return make_contractor(e->get1st(), !polarity, b, var_set);
}
if (e->isOr()) {
// TODO(soonhok): arbitrary number of args
assert(e->getArity() == 2);
contractor c1 = make_contractor(e->get1st(), polarity, b, var_set);
contractor c2 = make_contractor(e->get2nd(), polarity, b, var_set);
return mk_contractor_join(c1, c2);
}
if (e->isAnd()) {
vector<contractor> ctcs;
e = e->getCdr();
while (!e->isEnil()) {
ctcs.push_back(make_contractor(e->getCar(), polarity, b, var_set));
e = e->getCdr();
}
return mk_contractor_seq(ctcs);
} else {
return mk_contractor_ibex_fwdbwd(make_shared<nonlinear_constraint>(e, var_set, polarity));
}
}
contractor default_strategy::build_contractor(box const & box,
scoped_vec<shared_ptr<constraint>> const & ctrs,
bool const complete,
SMTConfig const & config) const {
bool const use_cache = true;
// 1. Categorize constraints
vector<shared_ptr<nonlinear_constraint>> nl_ctrs;
vector<shared_ptr<ode_constraint>> ode_ctrs_rev;
vector<shared_ptr<generic_forall_constraint>> generic_forall_ctrs;
for (shared_ptr<constraint> const ctr : ctrs.get_reverse()) {
switch (ctr->get_type()) {
case constraint_type::Nonlinear: {
auto nl_ctr = dynamic_pointer_cast<nonlinear_constraint>(ctr);
nl_ctrs.push_back(nl_ctr);
break;
}
case constraint_type::ODE: {
auto ode_ctr = dynamic_pointer_cast<ode_constraint>(ctr);
ode_ctrs_rev.push_back(ode_ctr);
break;
}
case constraint_type::GenericForall: {
auto gf_ctr = dynamic_pointer_cast<generic_forall_constraint>(ctr);
generic_forall_ctrs.push_back(gf_ctr);
break;
}
case constraint_type::ForallT: {
// Do nothing
break;
}
default:
DREAL_LOG_FATAL << "Unknown Constraint Type: " << ctr->get_type() << " " << *ctr << endl;
}
}
vector<shared_ptr<ode_constraint>> ode_ctrs(ode_ctrs_rev);
reverse(ode_ctrs.begin(), ode_ctrs.end());
vector<contractor> ctcs;
ctcs.reserve(ctrs.size());
// 2.0 Build Sample Contractor
if (config.nra_sample > 0 && complete) {
ctcs.push_back(mk_contractor_sample(box, config.nra_sample, ctrs.get_vec()));
}
// 2.1 Build nonlinear contractors
vector<contractor> nl_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
if (!nl_ctr->is_neq()) {
nl_ctcs.push_back(mk_contractor_ibex_fwdbwd(nl_ctr, use_cache));
} else {
// Case: != (not equal), do nothing
}
}
contractor nl_ctc = mk_contractor_seq(nl_ctcs);
ctcs.insert(ctcs.end(), nl_ctcs.begin(), nl_ctcs.end());
// 2.2. Build Polytope Contractor
if (config.nra_polytope) {
ctcs.push_back(mk_contractor_ibex_polytope(config.nra_precision, box.get_vars(), nl_ctrs));
}
// 2.3. Int Contractor
ctcs.push_back(mk_contractor_int(box));
// 2.4. Build generic forall contractors
for (auto const & generic_forall_ctr : generic_forall_ctrs) {
ctcs.push_back(mk_contractor_generic_forall(box, generic_forall_ctr));
}
if (complete && ode_ctrs.size() > 0) {
// Add ODE Contractors only for complete check
// 2.5. Build GSL Contractors (using CAPD4)
vector<contractor> ode_gsl_ctcs;
if (config.nra_ODE_sampling) {
// 2.5.1 Build Eval contractors
vector<contractor> eval_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
eval_ctcs.push_back(mk_contractor_eval(nl_ctr, false));
}
contractor eval_ctc = mk_contractor_seq(eval_ctcs);
if (config.nra_parallel) {
vector<contractor> nl_ctcs2;
for (auto const & nl_ctr : nl_ctrs) {
if (!nl_ctr->is_neq()) {
nl_ctcs2.push_back(mk_contractor_ibex_fwdbwd(nl_ctr, false));
} else {
// Case: != (not equal), do nothing
}
}
contractor nl_ctc2 = mk_contractor_seq(nl_ctcs2);
for (auto const & ode_ctr : ode_ctrs) {
// Add Forward ODE Pruning (Underapproximation, using GNU GSL)
ode_gsl_ctcs.push_back(mk_contractor_gsl(box, ode_ctr, eval_ctc, ode_direction::FWD, false, config.nra_ODE_fwd_timeout));
ode_gsl_ctcs.push_back(nl_ctc2);
}
} else {
for (auto const & ode_ctr : ode_ctrs) {
// Add Forward ODE Pruning (Underapproximation, using GNU GSL)
ode_gsl_ctcs.push_back(mk_contractor_gsl(box, ode_ctr, eval_ctc, ode_direction::FWD, use_cache, config.nra_ODE_fwd_timeout));
ode_gsl_ctcs.push_back(nl_ctc);
}
}
}
// 2.6. Build ODE Contractors (using CAPD4)
vector<contractor> ode_capd4_fwd_ctcs;
vector<contractor> ode_capd4_bwd_ctcs;
for (auto const & ode_ctr : ode_ctrs) {
// 2.6.1. Add Forward ODE Pruning (Overapproximation, using CAPD4)
if (config.nra_ODE_cache) {
ode_capd4_fwd_ctcs.emplace_back(
mk_contractor_cache(
mk_contractor_try(
mk_contractor_seq(mk_contractor_capd_full(box, ode_ctr, ode_direction::FWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_fwd_timeout),
nl_ctc))));
} else {
ode_capd4_fwd_ctcs.emplace_back(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::FWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_fwd_timeout),
nl_ctc)));
}
}
if (!config.nra_ODE_forward_only) {
// 2.6.2. Add Backward ODE Pruning (Overapproximation, using CAPD4)
for (auto const & ode_ctr : ode_ctrs_rev) {
if (config.nra_ODE_cache) {
ode_capd4_bwd_ctcs.emplace_back(
mk_contractor_cache(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::BWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_bwd_timeout),
nl_ctc))));
} else {
ode_capd4_bwd_ctcs.emplace_back(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::BWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_bwd_timeout),
nl_ctc)));
}
}
}
if (config.nra_ODE_sampling) {
if (config.nra_parallel) {
ctcs.push_back(mk_contractor_parallel_any(
mk_contractor_try_or(mk_contractor_throw_if_empty(mk_contractor_seq(ode_gsl_ctcs)),
mk_contractor_empty()),
mk_contractor_seq(mk_contractor_seq(ode_capd4_fwd_ctcs),
mk_contractor_seq(ode_capd4_bwd_ctcs))));
} else {
ctcs.push_back(
mk_contractor_try_or(
// Try Underapproximation(GSL) if it fails try Overapproximation(CAPD4)
mk_contractor_throw_if_empty(mk_contractor_seq(ode_gsl_ctcs)),
mk_contractor_seq(mk_contractor_seq(ode_capd4_fwd_ctcs),
mk_contractor_seq(ode_capd4_bwd_ctcs))));
}
} else {
ctcs.insert(ctcs.end(), ode_capd4_fwd_ctcs.begin(), ode_capd4_fwd_ctcs.end());
ctcs.insert(ctcs.end(), ode_capd4_bwd_ctcs.begin(), ode_capd4_bwd_ctcs.end());
}
}
if (complete) {
// 2.7 Build Eval contractors
vector<contractor> eval_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
eval_ctcs.push_back(mk_contractor_eval(nl_ctr, use_cache));
}
return mk_contractor_seq(mk_contractor_fixpoint(default_strategy::term_cond, ctcs),
mk_contractor_seq(eval_ctcs));
} else {
return mk_contractor_fixpoint(default_strategy::term_cond, ctcs);
}
}
