}/* Theory$camel::Theory$camel() */
void Theory$camel::check(Effort level) {
+ if (done() && !fullEffort(level)) {
+ return;
+ }
+
+ TimerStat::CodeTimer checkTimer(d_checkTime);
while(!done()) {
// Get all the assertions
return;
}
+ TimerStat::CodeTimer checkTimer(d_checkTime);
+
while(!done()) {
// Get all the assertions
Assertion assertion = get();
void TheoryArithPrivate::check(Theory::Effort effortLevel){
Assert(d_currentPropagationList.empty());
+ TimerStat::CodeTimer checkTimer(d_containing.d_checkTime);
//cout << "TheoryArithPrivate::check " << effortLevel << std::endl;
Debug("effortlevel") << "TheoryArithPrivate::check " << effortLevel << std::endl;
Debug("arith") << "TheoryArithPrivate::check begun " << effortLevel << std::endl;
d_numGetModelValConflicts("theory::arrays::number of getModelVal conflicts", 0),
d_numSetModelValSplits("theory::arrays::number of setModelVal splits", 0),
d_numSetModelValConflicts("theory::arrays::number of setModelVal conflicts", 0),
- d_checkTimer("theory::arrays::checkTime"),
d_ppEqualityEngine(u, "theory::arrays::TheoryArraysPP"),
d_ppFacts(u),
// d_ppCache(u),
StatisticsRegistry::registerStat(&d_numGetModelValConflicts);
StatisticsRegistry::registerStat(&d_numSetModelValSplits);
StatisticsRegistry::registerStat(&d_numSetModelValConflicts);
- StatisticsRegistry::registerStat(&d_checkTimer);
d_true = NodeManager::currentNM()->mkConst<bool>(true);
d_false = NodeManager::currentNM()->mkConst<bool>(false);
StatisticsRegistry::unregisterStat(&d_numGetModelValConflicts);
StatisticsRegistry::unregisterStat(&d_numSetModelValSplits);
StatisticsRegistry::unregisterStat(&d_numSetModelValConflicts);
- StatisticsRegistry::unregisterStat(&d_checkTimer);
}
void TheoryArrays::setMasterEqualityEngine(eq::EqualityEngine* eq) {
if (done() && !fullEffort(e)) {
return;
}
- TimerStat::CodeTimer codeTimer(d_checkTimer);
+ TimerStat::CodeTimer checkTimer(d_checkTime);
while (!done() && !d_conflict)
{
IntStat d_numSetModelValSplits;
/** conflicts in setModelVal */
IntStat d_numSetModelValConflicts;
- /** time spent in check() */
- TimerStat d_checkTimer;
public:
if (done() && !fullEffort(e)) {
return;
}
+ TimerStat::CodeTimer checkTimer(d_checkTime);
Debug("bitvector") << "TheoryBV::check(" << e << ")" << std::endl;
TimerStat::CodeTimer codeTimer(d_statistics.d_solveTimer);
// we may be getting new assertions so the model cache may not be sound
return;
}
+ TimerStat::CodeTimer checkTimer(d_checkTime);
+
Trace("datatypes-debug") << "Check effort " << e << std::endl;
while(!done() && !d_conflict) {
// Get all the assertions
}
void TheoryUFTim::check(Effort level) {
+ if (done() && !fullEffort(level)) {
+ return;
+ }
+
+ TimerStat::CodeTimer checkTimer(d_checkTime);
Debug("uf") << "uf: begin check(" << level << ")" << std::endl;
}
void TheoryIdl::check(Effort level) {
- //// Not needed for now, as no code outside while() loop below.
- // if (done() && !fullEffort(e)) {
- // return;
- // }
+ if (done() && !fullEffort(level)) {
+ return;
+ }
+
+ TimerStat::CodeTimer checkTimer(d_checkTime);
while(!done()) {
return;
}
- CodeTimer codeTimer(d_theoryTime);
+ TimerStat::CodeTimer checkTimer(d_checkTime);
Trace("quantifiers-check") << "quantifiers::check(" << e << ")" << std::endl;
while(!done()) {
}
void TheoryQuantifiers::propagate(Effort level){
- //CodeTimer codeTimer(d_theoryTime);
//getQuantifiersEngine()->propagate( level );
}
/** number of restarts */
int d_numRestarts;
- KEEP_STATISTIC(TimerStat, d_theoryTime, "theory::quantifiers::theoryTime");
-
eq::EqualityEngine* d_masterEqualityEngine;
public:
if (done() && !fullEffort(e)) {
return;
}
+ TimerStat::CodeTimer checkTimer(d_checkTime);
d_internal->check(e);
}
void TheorySetsPrivate::check(Theory::Effort level) {
- CodeTimer checkCodeTimer(d_statistics.d_checkTime);
-
while(!d_external.done() && !d_conflict) {
// Get all the assertions
Assertion assertion = d_external.get();
TheorySetsPrivate::Statistics::Statistics() :
- d_checkTime("theory::sets::time")
- , d_getModelValueTime("theory::sets::getModelValueTime")
+ d_getModelValueTime("theory::sets::getModelValueTime")
, d_memberLemmas("theory::sets::lemmas::member", 0)
, d_disequalityLemmas("theory::sets::lemmas::disequality", 0)
{
- StatisticsRegistry::registerStat(&d_checkTime);
StatisticsRegistry::registerStat(&d_getModelValueTime);
StatisticsRegistry::registerStat(&d_memberLemmas);
StatisticsRegistry::registerStat(&d_disequalityLemmas);
TheorySetsPrivate::Statistics::~Statistics() {
- StatisticsRegistry::unregisterStat(&d_checkTime);
StatisticsRegistry::unregisterStat(&d_getModelValueTime);
StatisticsRegistry::unregisterStat(&d_memberLemmas);
StatisticsRegistry::unregisterStat(&d_disequalityLemmas);
class Statistics {
public:
- TimerStat d_checkTime;
TimerStat d_getModelValueTime;
IntStat d_memberLemmas;
IntStat d_disequalityLemmas;
return;
}
+ TimerStat::CodeTimer checkTimer(d_checkTime);
+
bool polarity;
TNode atom;
}/* ostream& operator<<(ostream&, Theory::Effort) */
Theory::~Theory() {
+ StatisticsRegistry::unregisterStat(&d_checkTime);
StatisticsRegistry::unregisterStat(&d_computeCareGraphTime);
}
*/
QuantifiersEngine* d_quantEngine;
+protected:
+
// === STATISTICS ===
+ /** time spent in check calls */
+ TimerStat d_checkTime;
/** time spent in theory combination */
TimerStat d_computeCareGraphTime;
return ss.str();
}
-protected:
-
/**
* The only method to add suff to the care graph.
*/
, d_sharedTermsIndex(satContext, 0)
, d_careGraph(NULL)
, d_quantEngine(NULL)
+ , d_checkTime(statName(id, "checkTime"))
, d_computeCareGraphTime(statName(id, "computeCareGraphTime"))
, d_sharedTerms(satContext)
, d_out(&out)
, d_valuation(valuation)
, d_proofEnabled(false)
{
+ StatisticsRegistry::registerStat(&d_checkTime);
StatisticsRegistry::registerStat(&d_computeCareGraphTime);
}
return;
}
+ TimerStat::CodeTimer checkTimer(d_checkTime);
+
while (!done() && !d_conflict)
{
// Get all the assertions