/*
* 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 "CComputedConsequencesCacheHandler.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CComputedConsequencesCacheHandler::CComputedConsequencesCacheHandler(CComputedConsequencesCacheReader* satCacheReader, CComputedConsequencesCacheWriter* satCacheWriter) {
mSatCacheReader = satCacheReader;
mSatCacheWriter = satCacheWriter;
mTmpContext = nullptr;
mMemAllocMan = nullptr;
mWriteData = nullptr;
}
bool CComputedConsequencesCacheHandler::canCacheTypeConcept(CIndividual* individual, CConcept* concept, bool negation, CCalculationAlgorithmContext* calcAlgContext) {
CConcreteOntology* ontology = calcAlgContext->getProcessingDataBox()->getOntology();
CConsistence* consistence = ontology->getConsistence();
CBOXHASH* eqConCandHash = ontology->getTBox()->getEquivalentConceptCandidateHash(false);
if (consistence && concept->getTerminology()) {
CConsistenceData* consData = consistence->getConsistenceModelData();
if (consData) {
CConsistenceTaskData* consTaskData = dynamic_cast(consData);
if (consTaskData) {
CSatisfiableCalculationTask* detSatCalcTask = consTaskData->getDeterministicSatisfiableTask();
if (detSatCalcTask) {
CIndividualProcessNodeVector* detSatProcNodeVec = detSatCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
CIndividualProcessNode* detIndiNode = detSatProcNodeVec->getData(-individual->getIndividualID());
while (detIndiNode->getIndividualNodeID() != detIndiNode->getMergedIntoIndividualNodeID()) {
detIndiNode = detSatProcNodeVec->getData(detIndiNode->getMergedIntoIndividualNodeID());
}
CReapplyConceptLabelSet* detConSet = detIndiNode->getReapplyConceptLabelSet(false);
if (detConSet && !detConSet->containsConcept(concept,negation)) {
//if (concept->getTerminology() == ontology) {
// return true;
//}
CSatisfiableCalculationTask* compGraphCachedCalcTask = consTaskData->getCompletionGraphCachedSatisfiableTask();
CIndividualProcessNodeVector* compGraphCachedProcNodeVec = compGraphCachedCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
CIndividualProcessNode* compGraphCachedIndiNode = compGraphCachedProcNodeVec->getData(-individual->getIndividualID());
while (compGraphCachedIndiNode->getIndividualNodeID() != compGraphCachedIndiNode->getMergedIntoIndividualNodeID()) {
compGraphCachedIndiNode = detSatProcNodeVec->getData(compGraphCachedIndiNode->getIndividualNodeID());
}
CReapplyConceptLabelSet* compGraphCachedConSet = compGraphCachedIndiNode->getReapplyConceptLabelSet(false);
if (compGraphCachedConSet && compGraphCachedConSet->containsConcept(concept,negation)) {
return true;
}
if (!negation && eqConCandHash) {
CConcept* candidateConcept = eqConCandHash->value(concept);
if (compGraphCachedConSet && candidateConcept && compGraphCachedConSet->containsConcept(candidateConcept,false)) {
return true;
}
}
}
}
}
}
}
return false;
}
bool CComputedConsequencesCacheHandler::tryCacheTypeConcept(CIndividual* individual, CConcept* concept, bool negation, CCalculationAlgorithmContext* calcAlgContext) {
CComputedConsequencesTypesCacheEntry* typeCacheEntry = mSatCacheReader->getTypesCacheEntry(individual);
if ((!typeCacheEntry || !typeCacheEntry->hasConcept(concept,negation)) && canCacheTypeConcept(individual,concept,negation,calcAlgContext)) {
// try caching
prepareCacheMessages(calcAlgContext);
CTaskMemoryPoolAllocationManager* satCacheMemMan = mMemAllocMan;
CContextBase* tmpContext = mTmpContext;
CComputedConsequencesCacheWriteTypesData* unsatWriteData = CObjectAllocator< CComputedConsequencesCacheWriteTypesData >::allocateAndConstruct(satCacheMemMan);
unsatWriteData->initTypesCacheWriteData(individual,concept,negation);
addCacheMessages(unsatWriteData,calcAlgContext);
return true;
}
return false;
}
CSortedNegLinker* CComputedConsequencesCacheHandler::getCachedTypesConceptLinker(CIndividual* individual, CCalculationAlgorithmContext* calcAlgContext) {
CSortedNegLinker* typeConceptLinker = nullptr;
CComputedConsequencesTypesCacheEntry* typeCacheEntry = mSatCacheReader->getTypesCacheEntry(individual);
if (typeCacheEntry) {
typeConceptLinker = typeCacheEntry->getConceptLinker();
}
return typeConceptLinker;
}
bool CComputedConsequencesCacheHandler::prepareCacheMessages(CCalculationAlgorithmContext* calcAlgContext) {
if (!mMemAllocMan) {
CTaskMemoryPoolAllocationManager satCacheMemManCreaterMemMan(&mMemPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
mMemAllocMan = CObjectAllocator::allocateAndConstruct(&satCacheMemManCreaterMemMan);
mMemAllocMan->initTaskMemoryPoolAllocationManager(&mMemPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
mTmpContext = CObjectParameterizingAllocator< CContextBase,CMemoryAllocationManager* >::allocateAndConstructAndParameterize(mMemAllocMan,mMemAllocMan);
return true;
}
return false;
}
bool CComputedConsequencesCacheHandler::commitCacheMessages(CCalculationAlgorithmContext* calcAlgContext) {
if (mWriteData) {
CComputedConsequencesCacheWriteData* commitWriteData = nullptr;
CComputedConsequencesCacheWriteData* writeDataIt = mWriteData;
while (writeDataIt) {
CComputedConsequencesCacheWriteData* tmpWriteData = writeDataIt;
writeDataIt = (CComputedConsequencesCacheWriteData*)writeDataIt->getNext();
tmpWriteData->clearNext();
if (commitWriteData) {
commitWriteData = (CComputedConsequencesCacheWriteData*)tmpWriteData->append(commitWriteData);
} else {
commitWriteData = tmpWriteData;
}
}
mSatCacheWriter->writeCacheData(commitWriteData,mMemPoolCon.takeMemoryPools());
mWriteData = nullptr;
mMemAllocMan = nullptr;
mTmpContext = nullptr;
return true;
}
return false;
}
bool CComputedConsequencesCacheHandler::addCacheMessages(CComputedConsequencesCacheWriteData* expandWriteData, CCalculationAlgorithmContext* calcAlgContext) {
if (mWriteData) {
mWriteData = (CComputedConsequencesCacheWriteData*)expandWriteData->append(mWriteData);
} else {
mWriteData = expandWriteData;
}
commitCacheMessages(calcAlgContext);
return true;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude