void* ContextMemoryManager::newData(size_t size) {
// Use next available free location in current chunk
void* res = (void*)d_nextFree;
d_nextFree += size;
// Check if the request is too big for the chunk
if(d_nextFree > d_endChunk) {
newChunk();
res = (void*)d_nextFree;
d_nextFree += size;
AlwaysAssert(d_nextFree <= d_endChunk,
"Request is bigger than memory chunk size");
}
Debug("context") << "ContextMemoryManager::newData(" << size
<< ") returning " << res << " at level "
<< d_chunkList.size() << std::endl;
return res;
}
void ResourceManager::beginCall() {
d_perCallTimer.set(d_timeBudgetPerCall, !d_cpuTime);
d_thisCallResourceUsed = 0;
if (!d_on) return;
if (cumulativeLimitOn()) {
if (d_resourceBudgetCumulative) {
d_thisCallResourceBudget = d_resourceBudgetCumulative <= d_cumulativeResourceUsed ? 0 :
d_resourceBudgetCumulative - d_cumulativeResourceUsed;
}
if (d_timeBudgetCumulative) {
AlwaysAssert(d_cumulativeTimer.on());
// timer was on since the option was set
d_cumulativeTimeUsed = d_cumulativeTimer.elapsed();
d_thisCallTimeBudget = d_timeBudgetCumulative <= d_cumulativeTimeUsed? 0 :
d_timeBudgetCumulative - d_cumulativeTimeUsed;
d_cumulativeTimer.set(d_thisCallTimeBudget, d_cpuTime);
}
// we are out of resources so we shouldn't update the
// budget for this call to the per call budget
if (d_thisCallTimeBudget == 0 ||
d_thisCallResourceUsed == 0)
return;
}
if (perCallLimitOn()) {
// take min of what's left and per-call budget
if (d_resourceBudgetPerCall) {
d_thisCallResourceBudget = d_thisCallResourceBudget < d_resourceBudgetPerCall && d_thisCallResourceBudget != 0 ? d_thisCallResourceBudget : d_resourceBudgetPerCall;
}
if (d_timeBudgetPerCall) {
d_thisCallTimeBudget = d_thisCallTimeBudget < d_timeBudgetPerCall && d_thisCallTimeBudget != 0 ? d_thisCallTimeBudget : d_timeBudgetPerCall;
}
}
}
void* ContextMemoryManager::newData(size_t size) {
// Use next available free location in current chunk
void* res = (void*)d_nextFree;
d_nextFree += size;
// Check if the request is too big for the chunk
if(d_nextFree > d_endChunk) {
newChunk();
res = (void*)d_nextFree;
d_nextFree += size;
AlwaysAssert(d_nextFree <= d_endChunk,
"Request is bigger than memory chunk size");
}
Debug("context") << "ContextMemoryManager::newData(" << size
<< ") returning " << res << " at level "
<< d_chunkList.size() << std::endl;
#ifdef CVC4_VALGRIND
VALGRIND_MEMPOOL_ALLOC(this, static_cast<char*>(res), size);
d_allocations.back().push_back(static_cast<char*>(res));
#endif /* CVC4_VALGRIND */
return res;
}
void ProofOutputChannel::setIncomplete() {
Debug("pf::tp") << "ProofOutputChannel::setIncomplete called" << std::endl;
AlwaysAssert(false);
}
theory::LemmaStatus ProofOutputChannel::splitLemma(TNode, bool) {
AlwaysAssert(false);
return theory::LemmaStatus(TNode::null(), 0);
}
