/*
* 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 "CComputedConsequencesCache.h"
#include "CComputedConsequencesCacheWriter.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Cache {
CComputedConsequencesCache::CComputedConsequencesCache(CConfiguration* config, QString threadIdentifierName, CWatchDog *watchDogThread) : CThread(threadIdentifierName,watchDogThread) {
mReaderLinker = nullptr;
CMemoryAllocationManager* memMan = mContext.getMemoryAllocationManager();
mConfAllowedNonDetExpansionCount = 1;
if (config) {
mConfAllowedNonDetExpansionCount = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Optimization.SaturationExpansionSatisfiabilityCacheCount",1);
}
startThread(QThread::HighestPriority);
}
CComputedConsequencesCache::~CComputedConsequencesCache() {
}
CComputedConsequencesCache* CComputedConsequencesCache::writeCacheData(CComputedConsequencesCacheWriteData* writeData, CMemoryPool* memoryPools) {
postEvent(new CWriteComputedConcequencesCacheEntryEvent(writeData,memoryPools));
return this;
}
CCacheStatistics* CComputedConsequencesCache::getCacheStatistics() {
return &mCacheStat;
}
CComputedConsequencesCache* CComputedConsequencesCache::installWriteCacheData(CComputedConsequencesCacheWriteData* writeData, CComputedConsequencesCacheContext* context) {
CComputedConsequencesCacheWriteData* writeDataLinker = writeData;
while (writeDataLinker) {
if (writeDataLinker->getWriteDataType() == CComputedConsequencesCacheWriteData::CCWT_TYPE) {
CComputedConsequencesCacheWriteTypesData* cccwtd = (CComputedConsequencesCacheWriteTypesData*)writeDataLinker;
addTypesExpansionData(cccwtd,context);
}
writeDataLinker = (CComputedConsequencesCacheWriteData*)writeDataLinker->getNext();
}
return this;
}
CComputedConsequencesCache* CComputedConsequencesCache::addTypesExpansionData(CComputedConsequencesCacheWriteTypesData* cccwtd, CComputedConsequencesCacheContext* context) {
CIndividual* individual = cccwtd->getIndividual();
CConcept* conceptType = cccwtd->getConcept();
bool conceptNegation = cccwtd->getNegation();
CComputedConsequencesTypesCacheEntry* cacheEntry = getComputedTypesCacheEntryForNode(individual,context,true);
if (cacheEntry) {
CSortedNegLinker* conceptLinker = context->createConceptLinker();
conceptLinker->init(conceptType,conceptNegation);
cacheEntry->addConceptLinker(conceptLinker);
}
return this;
}
CComputedConsequencesTypesCacheEntry* CComputedConsequencesCache::getComputedTypesCacheEntryForNode(CIndividual* individual, CComputedConsequencesCacheContext* context, bool create) {
CIndividualProcessData* indProData = (CIndividualProcessData*)individual->getIndividualData();
CComputedConsequencesTypesCacheEntry* cacheEntry = nullptr;
if (indProData) {
cacheEntry = (CComputedConsequencesTypesCacheEntry*)indProData->getComputedConsequencesCachingData();
}
if (indProData && !cacheEntry && create) {
cacheEntry = CObjectParameterizingAllocator::allocateAndConstructAndParameterize(context->getMemoryAllocationManager(),context);
cacheEntry->initCacheEntry(individual);
indProData->setComputedConsequencesCachingData(cacheEntry);
}
return cacheEntry;
}
CComputedConsequencesCacheReader* CComputedConsequencesCache::createCacheReader() {
CComputedConsequencesCacheReader* readerLinker = new CComputedConsequencesCacheReader();
mReaderSyncMutex.lock();
mReaderLinker = readerLinker->append(mReaderLinker);
mReaderSyncMutex.unlock();
return readerLinker;
}
CComputedConsequencesCacheWriter* CComputedConsequencesCache::createCacheWriter() {
return new CComputedConsequencesCacheWriter(this);
}
bool CComputedConsequencesCache::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (CThread::processCustomsEvents(type,event)) {
return true;
} else if (type == EVENTWRITECOMPUTEDCONSEQUENCESCACHEDATAENTRY) {
CWriteComputedConcequencesCacheEntryEvent* wscde = (CWriteComputedConcequencesCacheEntryEvent*)event;
CMemoryPool* memoryPools = wscde->getMemoryPools();
CComputedConsequencesCacheWriteData* writeData = wscde->getWriteData();
installWriteCacheData(writeData,&mContext);
mContext.getMemoryPoolAllocationManager()->releaseTemporaryMemoryPools(memoryPools);
return true;
}
return false;
}
}; // end namespace Cache
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude