/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "CSignatureSatisfiableExpanderCache.h"
#include "CSignatureSatisfiableExpanderCacheWriter.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Cache {
CSignatureSatisfiableExpanderCache::CSignatureSatisfiableExpanderCache(CConfiguration* config, QString threadIdentifierName, CWatchDog *watchDogThread) : CThread(threadIdentifierName,watchDogThread) {
mConfig = config;
mWriteDataCount = 0;
mNextWriteCollectCount = 0;
mCollectCount = 0;
mStartWriteCollectCount = 1000;
mSlotLinker = nullptr;
mReaderLinker = nullptr;
mCollectMemoryPools = nullptr;
mCollectWriteData = nullptr;
CMemoryAllocationManager* memMan = mContext.getMemoryAllocationManager();
mSigItemHash = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(memMan,&mContext);
mIncompatibleSigSet = CObjectParameterizingAllocator< CCACHINGSET,CContext* >::allocateAndConstructAndParameterize(memMan,&mContext);
mAlreadyExpSigSet = CObjectParameterizingAllocator< CCACHINGSET,CContext* >::allocateAndConstructAndParameterize(memMan,&mContext);
mSignatureReferCountSet = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(memMan,&mContext);
mNextMemoryLevelRequiredSignatureRefCount = CConfigDataReader::readConfigInteger(config,"Konclude.Cache.SatisfiableExpander.InitialMemoryLevelForIncreaseRequiredSignatureReferenceCount",200*1024*1024);
mNextMemoryLevelIncreaseForRequiredSignatureReferenceCount = CConfigDataReader::readConfigInteger(config,"Konclude.Cache.SatisfiableExpander.NextMemoryLevelIncreaseForIncreaseRequiredSignatureReferenceCount",100*1024*1024);
mNextCacheEntryRequiredSignatureRefCount = CConfigDataReader::readConfigInteger(config,"Konclude.Cache.SatisfiableExpander.RequiredSignatureReferenceCountIncrease",1);
mNextCacheEntryRequiredSignatureReferenceCountIncrease = CConfigDataReader::readConfigInteger(config,"Konclude.Cache.SatisfiableExpander.RequiredSignatureReferenceCountIncrease",1);
startThread(QThread::HighestPriority);
}
CSignatureSatisfiableExpanderCache::~CSignatureSatisfiableExpanderCache() {
}
CCacheStatistics* CSignatureSatisfiableExpanderCache::getCacheStatistics() {
return &mCacheStat;
}
bool CSignatureSatisfiableExpanderCache::writeExpanderCachingData(CSignatureSatisfiableExpanderCacheContext* context, cint64 prevSignature, cint64 newSignature, CCACHINGLIST* cacheValueList, CCACHINGHASH* depHash) {
if (canCreateCacheEntryForSignature(newSignature,context)) {
if (!mSigItemHash->contains(newSignature)) {
CMemoryAllocationManager* memMan = context->getMemoryAllocationManager();
CSignatureSatisfiableExpanderCacheEntry* entry = nullptr;
if (prevSignature != 0) {
CSignatureSatisfiableExpanderCacheRedirectionItem* prevSigItem = mSigItemHash->value(prevSignature);
if (prevSigItem) {
entry = prevSigItem->getCacheEntry();
if (!isCachingDataExpandable(context,entry,prevSignature,cacheValueList)) {
// not compatible, only identical signatures
mIncompatibleSigSet->insert(prevSignature);
return false;
}
if (mAlreadyExpSigSet->contains(prevSignature)) {
entry->setMultipleExpanded(true);
}
}
}
if (!entry) {
entry = CObjectParameterizingAllocator< CSignatureSatisfiableExpanderCacheEntry,CSignatureSatisfiableExpanderCacheContext* >::allocateAndConstructAndParameterize(memMan,context);
}
writeExpanderCachingData(context,entry,prevSignature != 0,cacheValueList,depHash);
CSignatureSatisfiableExpanderCacheRedirectionItem* sigItem = CObjectAllocator< CSignatureSatisfiableExpanderCacheRedirectionItem >::allocateAndConstruct(memMan);
sigItem->initRedirectionItem(entry,newSignature,entry->getExpanderCacheValueCount());
mSigItemHash->insert(newSignature,sigItem);
mAlreadyExpSigSet->insert(prevSignature);
//mHasherItemHash.insert(CSignatureSatisfiableExpanderCacheHasher(entry->getExpanderCacheValueLinker(),entry->getExpanderCacheValueCount()),sigItem);
return true;
} else {
mIncompatibleSigSet->insert(newSignature);
}
}
return false;
}
bool CSignatureSatisfiableExpanderCache::isCachingDataExpandable(CSignatureSatisfiableExpanderCacheContext* context, CSignatureSatisfiableExpanderCacheEntry* entry, cint64 signature, CCACHINGLIST* cacheValueList) {
if (mIncompatibleSigSet->contains(signature) || entry->hasMultipleExpanded()) {
CCACHINGHASH* tagHash = entry->getTagExpanderCacheValueHash();
cint64 prevCount = entry->getExpanderCacheValueCount();
while (prevCount-- > 0 && !cacheValueList->isEmpty()) {
const CCacheValue& cacheValue = cacheValueList->takeFirst();
cint64 tag = cacheValue.getTag();
CExpanderCacheValueLinker* contCacheValue = tagHash->value(tag);
if (!contCacheValue || *contCacheValue->getCacheValue() != cacheValue) {
return false;
}
}
} else {
cint64 prevCount = entry->getExpanderCacheValueCount();
while (prevCount-- > 0 && !cacheValueList->isEmpty()) {
const CCacheValue& cacheValue = cacheValueList->takeFirst();
}
}
return true;
}
void CSignatureSatisfiableExpanderCache::writeExpanderCachingData(CSignatureSatisfiableExpanderCacheContext* context, CSignatureSatisfiableExpanderCacheEntry* entry, bool extending, CCACHINGLIST* cacheValueList, CCACHINGHASH* depHash) {
CMemoryAllocationManager* memMan = context->getMemoryAllocationManager();
CCACHINGHASH* tagHash = entry->getTagExpanderCacheValueHash();
CCACHINGHASH::const_iterator itDepEnd = depHash->constEnd();
CExpanderCacheValueLinker* lastExpCacheValueLinker = nullptr;
CExpanderCacheValueLinker* firstExpCacheValueLinker = nullptr;
CCACHINGHASH* newTagHash = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(memMan,context);
if (tagHash) {
*newTagHash = *tagHash;
}
mCacheStat.incCacheEntriesCount();
CCACHINGHASH* tagCacheValueHash = nullptr;
for (CCACHINGLIST::const_iterator it = cacheValueList->constBegin(), itEnd = cacheValueList->constEnd(); it != itEnd; ++it) {
const CCacheValue& cacheValue = *it;
cint64 tag = cacheValue.getTag();
if (!newTagHash->contains(tag)) {
CExpanderCacheValueLinker* expCacheValue = CObjectParameterizingAllocator< CExpanderCacheValueLinker,CSignatureSatisfiableExpanderCacheContext* >::allocateAndConstructAndParameterize(memMan,context);
expCacheValue->setCacheValue(cacheValue);
//if (cacheValue.getIdentification() == 0 || tag == 0) {
// bool bug = true;
//}
CCACHINGHASH::const_iterator itDep = depHash->constFind(tag);
while (itDep != itDepEnd && itDep.key() == tag) {
cint64 depTag = itDep.value();
CExpanderCacheValueLinker* depExpCacheValueLinker = newTagHash->value(depTag);
if (!depExpCacheValueLinker) {
if (!tagCacheValueHash) {
tagCacheValueHash = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(memMan,context);
CCACHINGLIST::const_iterator it2 = it;
for (++it2; it2 != itEnd; ++it2) {
const CCacheValue& cv = *it2;
cint64 cvTag = cv.getTag();
tagCacheValueHash->insert(cvTag,cv);
}
}
const CCacheValue& depCacheValue = tagCacheValueHash->value(depTag);
addExpanderCachingData(context,depCacheValue,newTagHash,depHash,tagCacheValueHash,lastExpCacheValueLinker,firstExpCacheValueLinker);
depExpCacheValueLinker = newTagHash->value(depTag);
}
expCacheValue->addExpanderDependency(depExpCacheValueLinker);
++itDep;
}
newTagHash->insert(tag,expCacheValue);
if (firstExpCacheValueLinker) {
lastExpCacheValueLinker->append(expCacheValue);
lastExpCacheValueLinker = expCacheValue;
} else {
firstExpCacheValueLinker = expCacheValue;
lastExpCacheValueLinker = firstExpCacheValueLinker;
}
}
}
entry->setTagExpanderCacheValueHash(newTagHash);
entry->appendExpanderCacheValueLinker(firstExpCacheValueLinker);
}
void CSignatureSatisfiableExpanderCache::addExpanderCachingData(CSignatureSatisfiableExpanderCacheContext* context, const CCacheValue& cacheValue, CCACHINGHASH* newTagHash, CCACHINGHASH* depHash, CCACHINGHASH* tagCacheValueHash, CExpanderCacheValueLinker*& lastExpCacheValueLinker, CExpanderCacheValueLinker*& firstExpCacheValueLinker) {
CMemoryAllocationManager* memMan = context->getMemoryAllocationManager();
CCACHINGHASH::const_iterator itDepEnd = depHash->constEnd();
cint64 tag = cacheValue.getTag();
if (!newTagHash->contains(tag)) {
CExpanderCacheValueLinker* expCacheValue = CObjectParameterizingAllocator< CExpanderCacheValueLinker,CSignatureSatisfiableExpanderCacheContext* >::allocateAndConstructAndParameterize(memMan,context);
expCacheValue->setCacheValue(cacheValue);
//if (cacheValue.getIdentification() == 0 || tag == 0) {
// bool bug = true;
//}
CCACHINGHASH::const_iterator itDep = depHash->constFind(tag);
while (itDep != itDepEnd && itDep.key() == tag) {
cint64 depTag = itDep.value();
CExpanderCacheValueLinker* depExpCacheValueLinker = newTagHash->value(depTag);
if (!depExpCacheValueLinker) {
const CCacheValue& depCacheValue = tagCacheValueHash->value(depTag);
addExpanderCachingData(context,depCacheValue,newTagHash,depHash,tagCacheValueHash,lastExpCacheValueLinker,firstExpCacheValueLinker);
depExpCacheValueLinker = newTagHash->value(depTag);
}
expCacheValue->addExpanderDependency(depExpCacheValueLinker);
++itDep;
}
newTagHash->insert(tag,expCacheValue);
if (firstExpCacheValueLinker) {
lastExpCacheValueLinker->append(expCacheValue);
lastExpCacheValueLinker = expCacheValue;
} else {
firstExpCacheValueLinker = expCacheValue;
lastExpCacheValueLinker = firstExpCacheValueLinker;
}
}
}
bool CSignatureSatisfiableExpanderCache::writeSatisfiableBranchedCachingData(CSignatureSatisfiableExpanderCacheContext* context, cint64 signature, CCACHINGLIST* cacheValueList, CCACHINGLIST* branchedValueList) {
CMemoryAllocationManager* memMan = context->getMemoryAllocationManager();
CSignatureSatisfiableExpanderCacheRedirectionItem* sSigItem = mSigItemHash->value(signature);
if (sSigItem) {
CSignatureSatisfiableExpanderCacheEntry* entry = sSigItem->getCacheEntry();
if (isCachingDataExpandable(context,entry,signature,cacheValueList)) {
if (!branchedValueList || branchedValueList->isEmpty()) {
entry->setSatisfiableWithoutBranchedConcepts(true);
} else {
CExpanderBranchedLinker* expBranch = CObjectParameterizingAllocator< CExpanderBranchedLinker,CSignatureSatisfiableExpanderCacheContext* >::allocateAndConstructAndParameterize(memMan,context);
for (CCACHINGLIST::const_iterator it = branchedValueList->constBegin(), itEnd = branchedValueList->constEnd(); it != itEnd; ++it) {
const CCacheValue& cacheValue = *it;
expBranch->appendCacheValue(cacheValue);
}
entry->appendExpanderBranchedLinker(expBranch);
}
entry->setSatisfiable(true);
return true;
}
}
return false;
}
void CSignatureSatisfiableExpanderCache::createReaderSlotUpdate(CSignatureSatisfiableExpanderCacheContext* context) {
CMemoryPoolProvider* memProv = context->getMemoryPoolAllocationManager();
CSignatureSatisfiableExpanderCacheSlotItem* slot = CObjectMemoryPoolAllocator::allocateAndConstructWithMemroyPool(memProv);
CMemoryPoolContainerAllocationManager slotMemMan(slot,memProv);
CMemoryAllocationManager* memMan = &slotMemMan;
CContextBase tmpContext(memMan);
CCACHINGHASH* slotSigItemHash = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(memMan,&tmpContext);
*slotSigItemHash = *mSigItemHash;
slotSigItemHash->detach();
slot->setSignatureItemHash(slotSigItemHash);
// currently not used
//CCACHINGHASH* slotHasherItemHash = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(memMan,&tmpContext);
//*slotHasherItemHash = *mHasherItemHash;
//slotHasherItemHash->detach();
//slot->setHasherItemHash(slotHasherItemHash);
if (mSlotLinker) {
mSlotLinker->append(slot);
} else {
mSlotLinker = slot;
}
CSignatureSatisfiableExpanderCacheReader* readerLinkerIt = mReaderLinker;
while (readerLinkerIt) {
slot->incReader();
readerLinkerIt->updateSlot(slot);
readerLinkerIt = readerLinkerIt->getNext();
}
}
void CSignatureSatisfiableExpanderCache::cleanUnusedSlots(CSignatureSatisfiableExpanderCacheContext* context) {
CMemoryPoolAllocationManager* memMan = context->getMemoryPoolAllocationManager();
CSignatureSatisfiableExpanderCacheSlotItem* slotLinkerIt = mSlotLinker;
CSignatureSatisfiableExpanderCacheSlotItem* lastSlotLinker = nullptr;
while (slotLinkerIt) {
CSignatureSatisfiableExpanderCacheSlotItem* tmpSlotLinker = nullptr;
if (!slotLinkerIt->hasCacheReaders()) {
tmpSlotLinker = slotLinkerIt;
}
CSignatureSatisfiableExpanderCacheSlotItem* nextSlotLinker = slotLinkerIt->getNext();
if (tmpSlotLinker) {
if (!lastSlotLinker) {
mSlotLinker = nextSlotLinker;
} else {
lastSlotLinker->setNext(nextSlotLinker);
}
CMemoryPool* memoryPools = tmpSlotLinker->getMemoryPools();
memMan->releaseTemporaryMemoryPools(memoryPools);
} else {
lastSlotLinker = slotLinkerIt;
}
slotLinkerIt = nextSlotLinker;
}
}
CSignatureSatisfiableExpanderCacheReader* CSignatureSatisfiableExpanderCache::createCacheReader() {
CSignatureSatisfiableExpanderCacheReader* reader = new CSignatureSatisfiableExpanderCacheReader();
mReaderSyncMutex.lock();
mReaderLinker = reader->append(mReaderLinker);
mReaderSyncMutex.unlock();
return reader;
}
CSignatureSatisfiableExpanderCacheWriter* CSignatureSatisfiableExpanderCache::createCacheWriter() {
CSignatureSatisfiableExpanderCacheWriter* writer = new CSignatureSatisfiableExpanderCacheWriter(this);
return writer;
}
CSignatureSatisfiableExpanderCache* CSignatureSatisfiableExpanderCache::writeCachedData(CSignatureSatisfiableExpanderCacheEntryWriteData* writeData, CMemoryPool* memoryPools) {
#ifdef KONCLUCE_SATISFIBALE_EXPANDER_CACHE_DIRECT_WRITING
CSignatureSatisfiableExpanderCacheEntryWriteData* dataLinkerIt = writeData;
bool allCachingSuccess = true;
bool oneCachingSuccess = false;
bool oneCachingExpSuccess = false;
while (dataLinkerIt) {
if (dataLinkerIt->getCacheWriteDataType() == CSignatureSatisfiableExpanderCacheEntryWriteData::SATEXPANDCACHEWRITEDATATYPE) {
CSignatureSatisfiableExpanderCacheEntryExpandWriteData* exWrDa = (CSignatureSatisfiableExpanderCacheEntryExpandWriteData*)dataLinkerIt;
cint64 prevSignature = exWrDa->getPrevSignature();
cint64 newSignature = exWrDa->getNewSignature();
CCACHINGLIST* cacheValueList = exWrDa->getCacheValueList();
CCACHINGHASH* depHash = exWrDa->getDepHash();
bool cached = writeExpanderCachingData(&mContext,prevSignature,newSignature,cacheValueList,depHash);
allCachingSuccess &= cached;
oneCachingSuccess |= cached;
oneCachingExpSuccess |= cached;
} else {
CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData* saBrWrDa = (CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData*)dataLinkerIt;
cint64 signature = saBrWrDa->getSignature();
CCACHINGLIST* cacheValueList = saBrWrDa->getCacheValueList();
CCACHINGLIST* branchedValueList = saBrWrDa->getBranchedValueList();
bool cached = writeSatisfiableBranchedCachingData(&mContext,signature,cacheValueList,branchedValueList);
allCachingSuccess &= cached;
oneCachingSuccess |= cached;
}
dataLinkerIt = (CSignatureSatisfiableExpanderCacheEntryWriteData*)dataLinkerIt->getNext();
}
if (oneCachingExpSuccess) {
createReaderSlotUpdate(&mContext);
cleanUnusedSlots(&mContext);
}
#else
postEvent(new CWriteCachedDataEvent(writeData,memoryPools));
#endif
return this;
}
CSignatureSatisfiableExpanderCache* CSignatureSatisfiableExpanderCache::writeExpandCached(cint64 prevSignature, cint64 newSignature, CCACHINGLIST* cacheValueList, CCACHINGHASH* depHash, CMemoryPool* memoryPools) {
#ifdef KONCLUCE_SATISFIBALE_EXPANDER_CACHE_DIRECT_WRITING
if (writeExpanderCachingData(&mContext,prevSignature,newSignature,cacheValueList,depHash)) {
createReaderSlotUpdate(&mContext);
cleanUnusedSlots(&mContext);
}
#else
postEvent(new CWriteExpandCachedEvent(prevSignature,newSignature,cacheValueList,depHash,memoryPools));
#endif
return this;
}
CSignatureSatisfiableExpanderCache* CSignatureSatisfiableExpanderCache::writeSatisfiableBranchCached(cint64 signature, CCACHINGLIST* cacheValueList, CCACHINGLIST* branchedList, CMemoryPool* memoryPools) {
#ifdef KONCLUCE_SATISFIBALE_EXPANDER_CACHE_DIRECT_WRITING
writeSatisfiableBranchedCachingData(&mContext,signature,cacheValueList,branchedList);
#else
postEvent(new CWriteSatisfiableBranchCachedEvent(signature,cacheValueList,branchedList,memoryPools));
#endif
return this;
}
bool CSignatureSatisfiableExpanderCache::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (CThread::processCustomsEvents(type,event)) {
return true;
} if (type == EVENTWRITEEXPANDCACHEDENTRY) {
CWriteExpandCachedEvent* wece = (CWriteExpandCachedEvent*)event;
cint64 prevSignature = wece->getPrevSignature();
cint64 newSignature = wece->getNewSignature();
CCACHINGLIST* cacheValueList = wece->getCacheValueList();
CCACHINGHASH* depHash = wece->getDepHash();
CMemoryPool* memoryPools = wece->getMemoryPools();
if (writeExpanderCachingData(&mContext,prevSignature,newSignature,cacheValueList,depHash)) {
createReaderSlotUpdate(&mContext);
cleanUnusedSlots(&mContext);
}
mContext.getMemoryPoolAllocationManager()->releaseTemporaryMemoryPools(memoryPools);
return true;
} else if (type == EVENTWRITESATISFIABLEBRANCHCACHEDENTRY) {
CWriteSatisfiableBranchCachedEvent* wsbce = (CWriteSatisfiableBranchCachedEvent*)event;
cint64 signature = wsbce->getSignature();
CCACHINGLIST* cacheValueList = wsbce->getCacheValueList();
CCACHINGLIST* branchedValueList = wsbce->getBranchedValueList();
CMemoryPool* memoryPools = wsbce->getMemoryPools();
writeSatisfiableBranchedCachingData(&mContext,signature,cacheValueList,branchedValueList);
mContext.getMemoryPoolAllocationManager()->releaseTemporaryMemoryPools(memoryPools);
return true;
} else if (type == EVENTWRITECACHEDDATAENTRY) {
CWriteCachedDataEvent* wcde = (CWriteCachedDataEvent*)event;
CMemoryPool* memoryPools = wcde->getMemoryPools();
CSignatureSatisfiableExpanderCacheEntryWriteData* newWriteData = (CSignatureSatisfiableExpanderCacheEntryWriteData*)wcde->getWriteData();
cint64 dataWriteCount = newWriteData->getCount();
mCollectCount += dataWriteCount;
mCollectMemoryPools = memoryPools->append(mCollectMemoryPools);
mCollectWriteData = (CSignatureSatisfiableExpanderCacheEntryWriteData*)newWriteData->append(mCollectWriteData);
if (mCollectCount >= mNextWriteCollectCount) {
if (mWriteDataCount > mStartWriteCollectCount) {
++mNextWriteCollectCount;
}
CSignatureSatisfiableExpanderCacheEntryWriteData* dataLinkerIt = mCollectWriteData;
bool allCachingSuccess = true;
bool oneCachingSuccess = false;
bool oneCachingExpSuccess = false;
while (dataLinkerIt) {
if (dataLinkerIt->getCacheWriteDataType() == CSignatureSatisfiableExpanderCacheEntryWriteData::SATEXPANDCACHEWRITEDATATYPE) {
CSignatureSatisfiableExpanderCacheEntryExpandWriteData* exWrDa = (CSignatureSatisfiableExpanderCacheEntryExpandWriteData*)dataLinkerIt;
cint64 prevSignature = exWrDa->getPrevSignature();
cint64 newSignature = exWrDa->getNewSignature();
CCACHINGLIST* cacheValueList = exWrDa->getCacheValueList();
CCACHINGHASH* depHash = exWrDa->getDepHash();
bool cached = writeExpanderCachingData(&mContext,prevSignature,newSignature,cacheValueList,depHash);
allCachingSuccess &= cached;
oneCachingSuccess |= cached;
oneCachingExpSuccess |= cached;
} else {
CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData* saBrWrDa = (CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData*)dataLinkerIt;
cint64 signature = saBrWrDa->getSignature();
CCACHINGLIST* cacheValueList = saBrWrDa->getCacheValueList();
CCACHINGLIST* branchedValueList = saBrWrDa->getBranchedValueList();
bool cached = writeSatisfiableBranchedCachingData(&mContext,signature,cacheValueList,branchedValueList);
allCachingSuccess &= cached;
oneCachingSuccess |= cached;
}
dataLinkerIt = (CSignatureSatisfiableExpanderCacheEntryWriteData*)dataLinkerIt->getNext();
}
if (oneCachingExpSuccess) {
createReaderSlotUpdate(&mContext);
cleanUnusedSlots(&mContext);
}
mContext.releaseTemporaryMemoryPools(mCollectMemoryPools);
mCacheStat.setMemoryConsumption(mContext.getMemoryConsumption());
mCollectWriteData = nullptr;
mCollectMemoryPools = nullptr;
mCollectCount = 0;
}
++mWriteDataCount;
return true;
}
return false;
}
cint64 CSignatureSatisfiableExpanderCache::getRequiredSignatureReferCountForNextCacheEntryCreation(CSignatureSatisfiableExpanderCacheContext* context) {
if (context->getMemoryConsumption() >= mNextMemoryLevelRequiredSignatureRefCount) {
mNextCacheEntryRequiredSignatureRefCount += mNextCacheEntryRequiredSignatureReferenceCountIncrease;
mNextMemoryLevelRequiredSignatureRefCount += mNextMemoryLevelIncreaseForRequiredSignatureReferenceCount;
}
return mNextCacheEntryRequiredSignatureRefCount;
}
cint64 CSignatureSatisfiableExpanderCache::canCreateCacheEntryForSignature(cint64 singature, CSignatureSatisfiableExpanderCacheContext* context) {
cint64& refCount = (*mSignatureReferCountSet)[singature];
++refCount;
if (refCount >= getRequiredSignatureReferCountForNextCacheEntryCreation(context)) {
return true;
}
return false;
}
}; // end namespace Cache
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude