/* * 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 "CSatisfiableExpanderCacheHandler.h" namespace Konclude { namespace Reasoner { namespace Kernel { namespace Algorithm { CSatisfiableExpanderCacheHandler::CSatisfiableExpanderCacheHandler(CSignatureSatisfiableExpanderCacheReader* satCacheReader, CSignatureSatisfiableExpanderCacheWriter* satCacheWriter) { mSatCacheReader = satCacheReader; mSatCacheWriter = satCacheWriter; mTmpContext = nullptr; mMemAllocMan = nullptr; mWriteData = nullptr; } CSatisfiableExpanderCacheHandler::~CSatisfiableExpanderCacheHandler() { } bool CSatisfiableExpanderCacheHandler::isIndividualNodeExpandCached(CIndividualProcessNode* individualNode, bool* satisfiable, CSignatureSatisfiableExpanderCacheEntry** entry, CCalculationAlgorithmContext* calcAlgContext) { CReapplyConceptLabelSet* conSet = individualNode->getReapplyConceptLabelSet(false); if (conSet && !conSet->getConceptStructure()->hasBindingPropagationConcepts() && !conSet->getConceptStructure()->hasDynamicCreatedConcepts()) { cint64 conSig = conSet->getConceptSignatureValue(); CSignatureSatisfiableExpanderCacheEntry* cachedEntry = mSatCacheReader->getCacheEntry(conSig); if (cachedEntry) { cint64 conSetCount = conSet->getConceptCount(); cint64 expCount = cachedEntry->getExpanderCacheValueCount(); if (expCount < conSetCount) { return false; } if (!compareIndividualNodeCompatibility(individualNode,cachedEntry,calcAlgContext)) { return false; } if (entry) { *entry = cachedEntry; } if (satisfiable) { *satisfiable = cachedEntry->isSatisfiable(); } return true; } } return false; } bool CSatisfiableExpanderCacheHandler::compareIndividualNodeCompatibility(CIndividualProcessNode* individualNode, CSignatureSatisfiableExpanderCacheEntry* cachedEntry, CCalculationAlgorithmContext* calcAlgContext) { CReapplyConceptLabelSet* conSet = individualNode->getReapplyConceptLabelSet(false); cint64 conSetCount = conSet->getConceptCount(); CExpanderCacheValueLinker* expCacheValueLinker = cachedEntry->getExpanderCacheValueLinker(); cint64 conNr = 0; while (expCacheValueLinker && conNr++ < conSetCount) { CCacheValue* cacheValue = expCacheValueLinker->getCacheValue(); CConcept* concept = (CConcept*)cacheValue->getIdentification(); CConceptDescriptor* conDes = nullptr; CDependencyTrackPoint* depTrackPoint = nullptr; if (conSet->getConceptDescriptor(concept,conDes,depTrackPoint)) { bool conNegated = conDes->isNegated(); bool cacheNegated = cacheValue->getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT; if (conNegated != cacheNegated || conDes->getConcept() != concept) { return false; } } else { return false; } expCacheValueLinker = expCacheValueLinker->getNext(); } return true; } bool CSatisfiableExpanderCacheHandler::cacheIndividualNodeSatisfiable(CIndividualProcessNode* individualNode, CCalculationAlgorithmContext* calcAlgContext) { STATINC(SATEXPCACHEWRITINGREQUESTCOUNT,calcAlgContext); STATINC(SATEXPCACHESATISFIABLEWRITINGREQUESTCOUNT,calcAlgContext); CReapplyConceptLabelSet* conSet = individualNode->getReapplyConceptLabelSet(false); if (conSet) { if (conSet->getConceptStructure()->hasBindingPropagationConcepts() || conSet->getConceptStructure()->hasDynamicCreatedConcepts()) { return false; } mTestConSet = conSet; cint64 conSetSignature = conSet->getConceptSignatureValue(); CIndividualNodeSatisfiableExpandingCacheStoringData* satStorData = (CIndividualNodeSatisfiableExpandingCacheStoringData*)individualNode->getIndividualSatisfiableCacheStoringData(false); if (satStorData) { if (satStorData->hasCachingError()) { return false; } if (satStorData->hasPreviousSatisfiableCached()) { if (satStorData->getLastCachedSignature() == conSetSignature) { return false; } } } bool localizedSatStorData = false; CMemoryAllocationManager* memMan = calcAlgContext->getUsedTemporaryMemoryAllocationManager(); CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager(); CIndividualNodeSatisfiableExpandingCacheStoringData* locSatStorData = (CIndividualNodeSatisfiableExpandingCacheStoringData*)individualNode->getIndividualSatisfiableCacheStoringData(true); if (locSatStorData && !satStorData) { // is probably caching by another thread return false; } if (!locSatStorData) { locSatStorData = CObjectAllocator::allocateAndConstruct(taskMemMan); locSatStorData->initSatisfiableExpandingCacheRetrievalData(satStorData); satStorData = locSatStorData; individualNode->setIndividualSatisfiableCacheStoringData(locSatStorData); localizedSatStorData = true; } CConceptDescriptor* lastAddedConDes = conSet->getAddingSortedConceptDescriptionLinker(); CSignatureSatisfiableExpanderCacheEntry* cachedEntry = mSatCacheReader->getCacheEntry(conSetSignature); if (cachedEntry) { STATINC(SATEXPCACHEWRITINGSIGNATUREALREADYCACHEDCOUNT,calcAlgContext); if (!compareIndividualNodeCompatibility(individualNode,cachedEntry,calcAlgContext)) { STATINC(SATEXPCACHEWRITINGSIGNATUREALREADYCACHEDINCOMPATIBLECOUNT,calcAlgContext); STATINC(SATEXPCACHEWRITINGERRORCOUNT,calcAlgContext); satStorData->setCachingError(true); return false; } else { if (!cachedEntry->isSatisfiable()) { // write only satisfiability STATINC(SATEXPCACHEWRITINGSIGNATUREALREADYCACHEDSATADDEDCOUNT,calcAlgContext); prepareCacheMessages(calcAlgContext); CTaskMemoryPoolAllocationManager* satCacheMemMan = mMemAllocMan; CContextBase* tmpContext = mTmpContext; CCACHINGLIST* cacheValueList = CObjectParameterizingAllocator< CCACHINGLIST,CContext* >::allocateAndConstructAndParameterize(satCacheMemMan,tmpContext); CCACHINGLIST* branchedList = CObjectParameterizingAllocator< CCACHINGLIST,CContext* >::allocateAndConstructAndParameterize(satCacheMemMan,tmpContext); CConceptDescriptor* conDesIt = lastAddedConDes; while (conDesIt) { CConceptDescriptor* conDes = conDesIt; cint64 conTag = conDes->getConceptTag(); CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDCONCEPT; if (conDes->getNegation()) { cacheValueIdentifier = CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT; } CCacheValue cacheValue; cacheValue.initCacheValue(conTag,(cint64)conDes->getConcept(),cacheValueIdentifier); cacheValueList->prepend(cacheValue); if (isCardinalityRestrictionCriticalForSatisfiable(individualNode,conDes,calcAlgContext)) { branchedList->append(cacheValue); } conDesIt = conDesIt->getNextConceptDesciptor(); } CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData* satBranchWriteData = CObjectAllocator< CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData >::allocateAndConstruct(satCacheMemMan); satBranchWriteData->initSatisfiableBranchWriteData(conSetSignature,cacheValueList,branchedList); addCacheMessages(satBranchWriteData,calcAlgContext); } satStorData->setLastCachedConceptDescriptor(lastAddedConDes); satStorData->setPreviousCached(true); satStorData->setPreviousSatisfiableCached(true); satStorData->setLastCachedSignature(conSetSignature); return true; } } CConceptDescriptor* lastCachedConceptDes = satStorData->getLastCachedConceptDescriptor(); CPROCESSINGLIST reverseConDesList(calcAlgContext->getUsedTaskProcessorContext()); // check whether to restart caching bool directBranched = false; bool dependencyToAncestor = false; cint64 lastBranchingTag = -1; CConceptDescriptor* conDesIt = lastAddedConDes; while (conDesIt != lastCachedConceptDes) { CConceptDescriptor* conDes = conDesIt; CDependencyTrackPoint* depTrackPoint = conDesIt->getDependencyTrackPoint(); if (hasDependencyToAncestor(individualNode,depTrackPoint,&directBranched,calcAlgContext)) { dependencyToAncestor = true; } reverseConDesList.prepend(conDes); conDesIt = conDesIt->getNextConceptDesciptor(); } if (dependencyToAncestor) { satStorData->setPreviousCached(false); satStorData->setPreviousSatisfiableCached(false); satStorData->setLastCachedSignature(0); satStorData->setLastCachedConceptDescriptor(nullptr); lastCachedConceptDes = nullptr; } if (directBranched) { satStorData->setIndividualNodeOrSuccessorBranchedConcept(true); } while (conDesIt) { CConceptDescriptor* conDes = conDesIt; reverseConDesList.prepend(conDes); conDesIt = conDesIt->getNextConceptDesciptor(); } cint64 lastConSetSignature = satStorData->getLastCachedSignature(); if (!satStorData->hasPreviousCached() && lastCachedConceptDes && lastConSetSignature != 0 && lastConSetSignature != conSetSignature) { cacheIndividualNodeExpansion(individualNode,satStorData,lastCachedConceptDes,nullptr,lastConSetSignature,0,calcAlgContext); } // try satisfiable caching prepareCacheMessages(calcAlgContext); CTaskMemoryPoolAllocationManager* satCacheMemMan = mMemAllocMan; CTaskMemoryPoolAllocationManager* expCacheMemMan = mMemAllocMan; CContextBase* tmpSatBranchContext = mTmpContext; CContextBase* tmpExpContext = mTmpContext; CCACHINGHASH* depHash = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(expCacheMemMan,tmpExpContext); CCACHINGLIST* expValueList = CObjectParameterizingAllocator< CCACHINGLIST,CContext* >::allocateAndConstructAndParameterize(expCacheMemMan,tmpExpContext); CCACHINGLIST* satValueList = CObjectParameterizingAllocator< CCACHINGLIST,CContext* >::allocateAndConstructAndParameterize(satCacheMemMan,tmpSatBranchContext); CCACHINGLIST* branchedList = CObjectParameterizingAllocator< CCACHINGLIST,CContext* >::allocateAndConstructAndParameterize(satCacheMemMan,tmpSatBranchContext); if (!satStorData->hasPreviousCached()) { lastCachedConceptDes = nullptr; lastConSetSignature = 0; } bool lastCachedConDesReached = false; bool cachingError = false; CPROCESSINGSET notBranchConceptsSet(calcAlgContext->getUsedTaskProcessorContext()); for (CPROCESSINGLIST::const_iterator it = reverseConDesList.constBegin(), itEnd = reverseConDesList.constEnd(); it != itEnd; ++it) { CConceptDescriptor* conDesIt = *it; CConceptDescriptor* conDes = conDesIt; CDependencyTrackPoint* depTrackPoint = nullptr; bool conceptDepInNodeOrSuccesssorBranched = false; cint64 conTag = conDes->getConceptTag(); if (lastCachedConDesReached) { CConceptDescriptor* conDes = conDesIt; CDependencyTrackPoint* depTrackPoint = conDes->getDependencyTrackPoint(); if (!simpleDependencyTracking(individualNode,conTag,depTrackPoint,depHash,¬BranchConceptsSet,&conceptDepInNodeOrSuccesssorBranched,calcAlgContext)) { CPROCESSINGSET depSet(calcAlgContext->getTaskProcessorContext()); CPROCESSINGLIST depList(calcAlgContext->getTaskProcessorContext()); cint64 baseAncDepth = individualNode->getIndividualAncestorDepth(); depSet.insert(CDepthDependencyPair(baseAncDepth,depTrackPoint)); depList.append(CDepthDependencyPair(baseAncDepth,depTrackPoint)); if (!complexDependencyTracking(individualNode,conTag,&depSet,&depList,depHash,¬BranchConceptsSet,&conceptDepInNodeOrSuccesssorBranched,calcAlgContext)) { // error cachingError = true; } } } bool addConceptToSatBranchedList = false; if (conceptDepInNodeOrSuccesssorBranched) { if (isConceptRelevantForSatisfiableBranch(individualNode,conDes,calcAlgContext)) { addConceptToSatBranchedList = true; } } else { notBranchConceptsSet.insert(conDes->getConceptTag()); if (isCardinalityRestrictionCriticalForSatisfiable(individualNode,conDes,calcAlgContext)) { addConceptToSatBranchedList = true; } CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDCONCEPT; if (conDes->getNegation()) { cacheValueIdentifier = CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT; } expValueList->append(CCacheValue(conTag,(cint64)conDes->getConcept(),cacheValueIdentifier)); satValueList->append(CCacheValue(conTag,(cint64)conDes->getConcept(),cacheValueIdentifier)); } if (addConceptToSatBranchedList) { STATINC(SATEXPCACHEWRITINGSIGSATCRITICALBRANCHCONCEPTADDEDCOUNT,calcAlgContext); CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDCONCEPT; if (conDes->getNegation()) { cacheValueIdentifier = CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT; } branchedList->append(CCacheValue(conTag,(cint64)conDes->getConcept(),cacheValueIdentifier)); } directBranched |= conceptDepInNodeOrSuccesssorBranched; if (!lastCachedConDesReached) { if (conDesIt == lastCachedConceptDes) { lastCachedConDesReached = true; } } } if (cachingError) { STATINC(SATEXPCACHEWRITINGERRORCOUNT,calcAlgContext); satStorData->setCachingError(true); } else { cint64 lastSig = lastConSetSignature; if (!satStorData->hasPreviousSatisfiableCached() && lastConSetSignature == conSetSignature) { lastSig = 0; } cint64 newSig = conSetSignature; STATINC(SATEXPCACHEWRITINGSIGNATUREEXPANSIONCOUNT,calcAlgContext); CSignatureSatisfiableExpanderCacheEntryExpandWriteData* expandWriteData = CObjectAllocator< CSignatureSatisfiableExpanderCacheEntryExpandWriteData >::allocateAndConstruct(expCacheMemMan); expandWriteData->initExpandWriteData(lastSig,newSig,expValueList,depHash); STATINC(SATEXPCACHEWRITINGSIGNATURESATISFIABLECOUNT,calcAlgContext); CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData* satBranchWriteData = CObjectAllocator< CSignatureSatisfiableExpanderCacheEntrySatisfiableBranchWriteData >::allocateAndConstruct(satCacheMemMan); satBranchWriteData->initSatisfiableBranchWriteData(newSig,satValueList,branchedList); satBranchWriteData->setNext(expandWriteData); addCacheMessages(satBranchWriteData,calcAlgContext); satStorData->setPreviousCached(true); satStorData->setPreviousSatisfiableCached(true); satStorData->setLastCachedSignature(newSig); satStorData->setLastCachedConceptDescriptor(lastAddedConDes); satStorData->setIndividualNodeOrSuccessorBranchedConcept(directBranched); return true; } } return false; } bool CSatisfiableExpanderCacheHandler::cacheIndividualNodeExpansion(CIndividualProcessNode* individualNode, CCalculationAlgorithmContext* calcAlgContext) { STATINC(SATEXPCACHEWRITINGREQUESTCOUNT,calcAlgContext); STATINC(SATEXPCACHESATISFIABLEWRITINGREQUESTCOUNT,calcAlgContext); CReapplyConceptLabelSet* conSet = individualNode->getReapplyConceptLabelSet(false); mTestConSet = conSet; cint64 conSetSignature = conSet->getConceptSignatureValue(); CIndividualNodeSatisfiableExpandingCacheStoringData* satStorData = (CIndividualNodeSatisfiableExpandingCacheStoringData*)individualNode->getIndividualSatisfiableCacheStoringData(false); if (satStorData) { if (satStorData->hasCachingError()) { return false; } if (satStorData->hasIndividualNodeOrSuccessorBranchedConcept()) { return false; } if (satStorData->getLastCachedSignature() == conSetSignature) { return false; } } CMemoryAllocationManager* memMan = calcAlgContext->getUsedTemporaryMemoryAllocationManager(); CMemoryAllocationManager* taskMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager(); CIndividualNodeSatisfiableExpandingCacheStoringData* locSatStorData = (CIndividualNodeSatisfiableExpandingCacheStoringData*)individualNode->getIndividualSatisfiableCacheStoringData(true); if (locSatStorData && !satStorData) { // is probably caching by another thread return false; } if (!locSatStorData) { locSatStorData = CObjectAllocator::allocateAndConstruct(taskMemMan); locSatStorData->initSatisfiableExpandingCacheRetrievalData(satStorData); satStorData = locSatStorData; individualNode->setIndividualSatisfiableCacheStoringData(locSatStorData); } CConceptDescriptor* lastAddedConDes = conSet->getAddingSortedConceptDescriptionLinker(); CConceptDescriptor* lastCachedConceptDes = satStorData->getLastCachedConceptDescriptor(); if (!satStorData->hasPreviousCached() && !lastCachedConceptDes) { satStorData->setLastCachedConceptDescriptor(lastAddedConDes); satStorData->setLastCachedSignature(conSetSignature); STATINC(SATEXPCACHEWRITINGEXPANSIONDELAYEDCOUNT,calcAlgContext); return true; } CSignatureSatisfiableExpanderCacheEntry* cachedEntry = mSatCacheReader->getCacheEntry(conSetSignature); if (cachedEntry) { STATINC(SATEXPCACHEWRITINGSIGNATUREALREADYCACHEDCOUNT,calcAlgContext); cint64 conSetCount = conSet->getConceptCount(); cint64 expCount = cachedEntry->getExpanderCacheValueCount(); if (expCount < conSetCount) { return false; } if (!compareIndividualNodeCompatibility(individualNode,cachedEntry,calcAlgContext)) { STATINC(SATEXPCACHEWRITINGSIGNATUREALREADYCACHEDINCOMPATIBLECOUNT,calcAlgContext); STATINC(SATEXPCACHEWRITINGERRORCOUNT,calcAlgContext); satStorData->setCachingError(true); return false; } else { satStorData->setLastCachedConceptDescriptor(lastAddedConDes); satStorData->setPreviousCached(true); satStorData->setLastCachedSignature(conSetSignature); return true; } } //CConceptDescriptor* testConDesIt = lastAddedConDes; //while (testConDesIt && testConDesIt->hasNext() && testConDesIt->getNextConceptDesciptor()->hasNext()) { // testConDesIt = testConDesIt->getNextConceptDesciptor(); //} //QString conString; //if (testConDesIt) { // conString = CIRIName::getRecentIRIName(testConDesIt->getConcept()->getClassNameLinker()); // if (conString == "http://www.owllink.org/testsuite/galen#Diabetes" || conString == "http://www.owllink.org/testsuite/galen#ProperHepaticArtery") { // bool bug = true; // } //} // check whether to restart caching bool directBranched = false; bool dependencyToAncestor = false; CConceptDescriptor* conDesIt = lastAddedConDes; while (conDesIt != lastCachedConceptDes) { CConceptDescriptor* conDes = conDesIt; CDependencyTrackPoint* depTrackPoint = conDes->getDependencyTrackPoint(); if (hasDependencyToAncestor(individualNode,depTrackPoint,&directBranched,calcAlgContext)) { dependencyToAncestor = true; } conDesIt = conDesIt->getNextConceptDesciptor(); } if (dependencyToAncestor) { satStorData->setPreviousCached(false); satStorData->setPreviousSatisfiableCached(false); satStorData->setLastCachedSignature(conSetSignature); satStorData->setLastCachedConceptDescriptor(lastAddedConDes); return true; } if (directBranched) { satStorData->setIndividualNodeOrSuccessorBranchedConcept(true); return false; } cint64 lastConSetSignature = satStorData->getLastCachedSignature(); if (!satStorData->hasPreviousCached() && lastCachedConceptDes && lastConSetSignature != 0) { cacheIndividualNodeExpansion(individualNode,satStorData,lastCachedConceptDes,nullptr,lastConSetSignature,0,calcAlgContext); } if (!satStorData->hasCachingError() && !satStorData->hasIndividualNodeOrSuccessorBranchedConcept()) { cacheIndividualNodeExpansion(individualNode,satStorData,lastAddedConDes,lastCachedConceptDes,conSetSignature,lastConSetSignature,calcAlgContext); } //commitCacheMessages(calcAlgContext); return false; } bool CSatisfiableExpanderCacheHandler::cacheIndividualNodeExpansion(CIndividualProcessNode* individualNode, CIndividualNodeSatisfiableExpandingCacheStoringData* satStorData, CConceptDescriptor* lastAddedConDes, CConceptDescriptor* lastCachedConceptDes, cint64 lastSignature, cint64 lastCachedSignature, CCalculationAlgorithmContext* calcAlgContext) { CReapplyConceptLabelSet* conSet = individualNode->getReapplyConceptLabelSet(false); // try caching prepareCacheMessages(calcAlgContext); CTaskMemoryPoolAllocationManager* satCacheMemMan = mMemAllocMan; CContextBase* tmpContext = mTmpContext; CCACHINGHASH* depHash = CObjectParameterizingAllocator< CCACHINGHASH,CContext* >::allocateAndConstructAndParameterize(satCacheMemMan,tmpContext); CCACHINGLIST* cacheValueList = CObjectParameterizingAllocator< CCACHINGLIST,CContext* >::allocateAndConstructAndParameterize(satCacheMemMan,tmpContext); CConceptDescriptor* conDesIt = lastAddedConDes; bool directBranched = false; bool cachingError = false; if (lastCachedConceptDes) { while (conDesIt != lastCachedConceptDes && !directBranched && !cachingError) { CConceptDescriptor* conDes = conDesIt; CDependencyTrackPoint* depTrackPoint = conDes->getDependencyTrackPoint(); cint64 conTag = conDes->getConceptTag(); if (!simpleDependencyTracking(individualNode,conTag,depTrackPoint,depHash,nullptr,&directBranched,calcAlgContext)) { CPROCESSINGSET depSet(calcAlgContext->getTaskProcessorContext()); CPROCESSINGLIST depList(calcAlgContext->getTaskProcessorContext()); cint64 baseAncDepth = individualNode->getIndividualAncestorDepth(); depSet.insert(CDepthDependencyPair(baseAncDepth,depTrackPoint)); depList.append(CDepthDependencyPair(baseAncDepth,depTrackPoint)); if (!complexDependencyTracking(individualNode,conTag,&depSet,&depList,depHash,nullptr,&directBranched,calcAlgContext)) { // error cachingError = true; } } CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDCONCEPT; if (conDes->getNegation()) { cacheValueIdentifier = CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT; } cacheValueList->prepend(CCacheValue(conTag,(cint64)conDes->getConcept(),cacheValueIdentifier)); conDesIt = conDesIt->getNextConceptDesciptor(); } } if (directBranched || cachingError) { if (directBranched) { satStorData->setIndividualNodeOrSuccessorBranchedConcept(true); } if (cachingError) { STATINC(SATEXPCACHEWRITINGERRORCOUNT,calcAlgContext); satStorData->setCachingError(true); } } else { while (conDesIt) { CConceptDescriptor* conDes = conDesIt; cint64 conTag = conDes->getConceptTag(); CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDCONCEPT; if (conDes->getNegation()) { cacheValueIdentifier = CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT; } cacheValueList->prepend(CCacheValue(conTag,(cint64)conDes->getConcept(),cacheValueIdentifier)); conDesIt = conDesIt->getNextConceptDesciptor(); } cint64 lastSig = lastCachedSignature; cint64 newSig = lastSignature; STATINC(SATEXPCACHEWRITINGSIGNATUREEXPANSIONCOUNT,calcAlgContext); CSignatureSatisfiableExpanderCacheEntryExpandWriteData* expandWriteData = CObjectAllocator< CSignatureSatisfiableExpanderCacheEntryExpandWriteData >::allocateAndConstruct(satCacheMemMan); expandWriteData->initExpandWriteData(lastSig,newSig,cacheValueList,depHash); addCacheMessages(expandWriteData,calcAlgContext); satStorData->setPreviousCached(true); satStorData->setLastCachedSignature(newSig); satStorData->setLastCachedConceptDescriptor(lastAddedConDes); return true; } return false; } bool CSatisfiableExpanderCacheHandler::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 CSatisfiableExpanderCacheHandler::commitCacheMessages(CCalculationAlgorithmContext* calcAlgContext) { if (mWriteData) { CSignatureSatisfiableExpanderCacheEntryWriteData* commitWriteData = nullptr; CSignatureSatisfiableExpanderCacheEntryWriteData* writeDataIt = mWriteData; while (writeDataIt) { CSignatureSatisfiableExpanderCacheEntryWriteData* tmpWriteData = writeDataIt; writeDataIt = (CSignatureSatisfiableExpanderCacheEntryWriteData*)writeDataIt->getNext(); tmpWriteData->clearNext(); if (commitWriteData) { commitWriteData = (CSignatureSatisfiableExpanderCacheEntryWriteData*)tmpWriteData->append(commitWriteData); } else { commitWriteData = tmpWriteData; } } mSatCacheWriter->writeCachedData(commitWriteData,mMemPoolCon.takeMemoryPools()); mWriteData = nullptr; mMemAllocMan = nullptr; mTmpContext = nullptr; return true; } return false; } bool CSatisfiableExpanderCacheHandler::addCacheMessages(CSignatureSatisfiableExpanderCacheEntryWriteData* expandWriteData, CCalculationAlgorithmContext* calcAlgContext) { if (mWriteData) { mWriteData = (CSignatureSatisfiableExpanderCacheEntryWriteData*)expandWriteData->append(mWriteData); } else { mWriteData = expandWriteData; } //commitCacheMessages(calcAlgContext); return true; } bool CSatisfiableExpanderCacheHandler::isCardinalityRestrictionCriticalForSatisfiable(CIndividualProcessNode* individualNode, CConceptDescriptor* conDes, CCalculationAlgorithmContext* calcAlgContext) { CConcept* concept = conDes->getConcept(); bool conNeg = conDes->getNegation(); cint64 conCode = concept->getOperatorCode(); if (!conNeg && (conCode == CCATMOST) || conNeg && (conCode == CCATLEAST)) { cint64 cardinality = concept->getParameter() - 1*conNeg; if (cardinality > 1) { CRole* role = concept->getRole(); if (role) { cint64 succCount = individualNode->getRoleSuccessorCount(role); if (succCount >= cardinality) { return hasInverseSubRole(role,calcAlgContext); } } } } return false; } bool CSatisfiableExpanderCacheHandler::hasInverseSubRole(CRole* role, CCalculationAlgorithmContext* calcAlgContext) { return true; } bool CSatisfiableExpanderCacheHandler::hasInverseSuperRole(CRole* role, CCalculationAlgorithmContext* calcAlgContext) { return true; } bool CSatisfiableExpanderCacheHandler::isConceptRelevantForSatisfiableBranch(CIndividualProcessNode* individualNode, CConceptDescriptor* conDes, CCalculationAlgorithmContext* calcAlgContext) { CConcept* concept = conDes->getConcept(); bool conNeg = conDes->getNegation(); cint64 conCode = concept->getOperatorCode(); CConceptOperator* conOperator = concept->getConceptOperator(); if (!conNeg && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_ALL_AQALL_TYPE)) || conNeg && (conCode == CCSOME)) { CRole* role = concept->getRole(); if (role) { return hasInverseSubRole(role,calcAlgContext); } } if (!conNeg && (conCode == CCATMOST) || conNeg && (conCode == CCATLEAST)) { CRole* role = concept->getRole(); if (role) { if (hasInverseSubRole(role,calcAlgContext)) { cint64 cardinality = concept->getParameter() - 1*conNeg; cint64 succCount = individualNode->getRoleSuccessorCount(role); if (succCount >= cardinality) { return true; } return false; } else { return false; } } } if (!conNeg && (conCode == CCSOME || conCode == CCAQSOME || conCode == CCATLEAST) || conNeg && (conCode == CCALL || conCode == CCATMOST)) { CRole* role = concept->getRole(); if (role) { // test has ATMOST restriction for some super role CSortedNegLinker* superRoleIt = role->getIndirectSuperRoleList(); while (superRoleIt) { if (!superRoleIt->isNegated()) { CRole* superRole = superRoleIt->getData(); CReapplyQueueIterator reapplyIt = individualNode->getRoleReapplyIterator(superRole,false); while (reapplyIt.hasNext()) { CReapplyConceptDescriptor* reapplyDes = reapplyIt.next(); CConceptDescriptor* reapplyConDes = reapplyDes->getConceptDescriptor(); CConcept* reapplyConcept = reapplyConDes->getConcept(); CRole* reapplyRole = reapplyConcept->getRole(); bool reapplyConNeg = reapplyConDes->getNegation(); cint64 reapplyConOpCode = reapplyConcept->getOperatorCode(); if (reapplyConNeg && reapplyConOpCode == CCATLEAST || !reapplyConNeg && reapplyConOpCode == CCATMOST) { cint64 cardinality = reapplyConcept->getParameter() - 1*reapplyConNeg; cint64 succCount = individualNode->getRoleSuccessorCount(role); if (succCount >= cardinality) { return hasInverseSubRole(reapplyRole,calcAlgContext); } } } } superRoleIt = superRoleIt->getNext(); } return false; } } if (!conNeg && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_AQAND_TYPE))) { return isAutomatConceptRelevantForSatisfiableBranch(individualNode,concept,conNeg,calcAlgContext); } return false; } bool CSatisfiableExpanderCacheHandler::isAutomatConceptRelevantForSatisfiableBranch(CIndividualProcessNode* individualNode, CConcept* concept, bool conNegation, CCalculationAlgorithmContext* calcAlgContext) { cint64 conCode = concept->getOperatorCode(); CConceptOperator* conOperator = concept->getConceptOperator(); if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_AQALL_TYPE)) { CRole* role = concept->getRole(); if (role) { CSortedNegLinker* superRoleIt = role->getIndirectSuperRoleList(); while (superRoleIt) { if (superRoleIt->isNegated()) { return true; } superRoleIt = superRoleIt->getNext(); } } } else if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_AQAND_TYPE)) { CSortedNegLinker* opConLinkerIt = concept->getOperandList(); while (opConLinkerIt) { CConcept* opCon = opConLinkerIt->getData(); bool opNeg = opConLinkerIt->isNegated(); if (isAutomatConceptRelevantForSatisfiableBranch(individualNode,opCon,opNeg,calcAlgContext)) { return true; } opConLinkerIt = opConLinkerIt->getNext(); } } return false; } bool CSatisfiableExpanderCacheHandler::simpleDependencyTracking(CIndividualProcessNode* individualNode, cint64 conTag, CDependencyTrackPoint* depTrackPoint, CCACHINGHASH* depHash, CPROCESSINGSET* notBranchConceptsSet, bool* branchedFlag, CCalculationAlgorithmContext* calcAlgContext) { if (branchedFlag && !depTrackPoint->isPointingToDeterministicDependencyNode()) { *branchedFlag = true; return true; } if (depTrackPoint->isPointingToIndependentDependencyNode()) { return true; } CDependencyNode* depNode = depTrackPoint->getDependencyNode(); if (depNode->hasAdditionalDependencies()) { return false; } if (depNode->hasAppropriateIndividualNode()) { CIndividualProcessNode* appIndiNode = depNode->getAppropriateIndividualNode(); cint64 appIndiDepth = appIndiNode->getIndividualAncestorDepth(); cint64 baseDepth = individualNode->getIndividualAncestorDepth(); if (appIndiDepth != baseDepth) { return false; } } CConceptDescriptor* conDes = depNode->getConceptDescriptor(); if (conDes) { cint64 depConTag = conDes->getConceptTag(); if (branchedFlag && notBranchConceptsSet && !notBranchConceptsSet->contains(conDes->getConceptTag())) { *branchedFlag = true; return true; } depHash->insertMulti(conTag,depConTag); //CConceptDescriptor* cD = nullptr; //CDependencyTrackPoint* dTP = nullptr; //if (individualNode->getReapplyConceptLabelSet(false)->getConceptDescriptor(conTag,cD,dTP)) { // if (cD->isNegated() && cD->getConcept()->getOperatorCode() == CCSUB) { // if (conDes->isNegated() && conDes->getConcept()->getOperatorCode() == CCSUB) { // bool bug = true; // } // } //} //CConceptDescriptor* cD = nullptr; //CDependencyTrackPoint* dTP = nullptr; //if (!individualNode->getReapplyConceptLabelSet(false)->getConceptDescriptor(depConTag,cD,dTP)) { // bool bug = true; //} else { // CConceptDescriptor* conDesIt = cD; // while (conDesIt) { // if (conDesIt->getConceptTag() == conTag) { // bool bug = true; // } // conDesIt = conDesIt->getNext(); // } // bool foundDepTag = false; // conDesIt = conDes; // while (conDesIt) { // if (conDesIt->getConceptTag() == depConTag) { // foundDepTag = true; // } // conDesIt = conDesIt->getNext(); // } // if (!foundDepTag) { // bool bug = true; // } //} return true; } return false; } bool CSatisfiableExpanderCacheHandler::complexDependencyTracking(CIndividualProcessNode* individualNode, cint64 conTag, CPROCESSINGSET* depSet, CPROCESSINGLIST* depList, CCACHINGHASH* depHash, CPROCESSINGSET* notBranchConceptsSet, bool* branchedFlag, CCalculationAlgorithmContext* calcAlgContext) { cint64 baseAncDepth = individualNode->getIndividualAncestorDepth(); while (!depList->isEmpty()) { CDepthDependencyPair depthDepPair(depList->takeFirst()); cint64 ancDepth = depthDepPair.first; CDependencyTrackPoint* depTrackPoint = depthDepPair.second; if (branchedFlag && !depTrackPoint->isPointingToDeterministicDependencyNode()) { *branchedFlag = true; return true; } CDependencyNode* depNode = depTrackPoint->getDependencyNode(); CIndividualProcessNode* appIndiNode = depNode->getAppropriateIndividualNode(); cint64 newAncDepth = ancDepth; bool continueDepLoading = true; if (appIndiNode) { newAncDepth = appIndiNode->getIndividualAncestorDepth(); } if (newAncDepth == baseAncDepth) { CConceptDescriptor* conDes = depNode->getConceptDescriptor(); if (conDes) { if (branchedFlag && notBranchConceptsSet) { if (!notBranchConceptsSet->contains(conDes->getConceptTag())) { *branchedFlag = true; return true; } } continueDepLoading = false; cint64 depConTag = conDes->getConceptTag(); if (depConTag != conTag) { depHash->insertMulti(conTag,depConTag); //CConceptDescriptor* cD = nullptr; //CDependencyTrackPoint* dTP = nullptr; //if (individualNode->getReapplyConceptLabelSet(false)->getConceptDescriptor(conTag,cD,dTP)) { // if (cD->isNegated() && cD->getConcept()->getOperatorCode() == CCSUB) { // if (conDes->isNegated() && conDes->getConcept()->getOperatorCode() == CCSUB) { // bool bug = true; // } // } //} //CConceptDescriptor* cD = nullptr; //CDependencyTrackPoint* dTP = nullptr; //if (!individualNode->getReapplyConceptLabelSet(false)->getConceptDescriptor(depConTag,cD,dTP)) { // bool bug = true; //} else { // CConceptDescriptor* conDesIt = cD; // while (conDesIt) { // if (conDesIt->getConceptTag() == conTag) { // bool bug = true; // } // conDesIt = conDesIt->getNext(); // } // bool foundDepTag = false; // conDesIt = conDes; // while (conDesIt) { // if (conDesIt->getConceptTag() == depConTag) { // foundDepTag = true; // } // conDesIt = conDesIt->getNext(); // } // if (!foundDepTag) { // bool bug = true; // } //} } } } if (newAncDepth < baseAncDepth) { return false; } if (continueDepLoading) { CDependencyTrackPoint* prevDepTrackPoint = depNode->getPreviousDependencyTrackPoint(); cint64 nextAncDepth = newAncDepth; CDependencyNode* nextDepNode = prevDepTrackPoint->getDependencyNode(); if (nextDepNode && nextDepNode->hasAppropriateIndividualNode()) { nextAncDepth = nextDepNode->getAppropriateIndividualNode()->getIndividualAncestorDepth(); } if (!depSet->contains(CDepthDependencyPair(nextAncDepth,prevDepTrackPoint))) { depSet->insert(CDepthDependencyPair(nextAncDepth,prevDepTrackPoint)); depList->append(CDepthDependencyPair(nextAncDepth,prevDepTrackPoint)); } } CDependencyIterator depIt = depNode->getAdditionalDependencyIterator(); while (depIt.hasNext()) { CDependency* dependency = depIt.nextDependency(); // load additional dependencies CDependencyTrackPoint* prevDepTrackPoint = dependency->getPreviousDependencyTrackPoint(); cint64 nextAncDepth = ancDepth; CDependencyNode* nextDepNode = prevDepTrackPoint->getDependencyNode(); if (nextDepNode && nextDepNode->hasAppropriateIndividualNode()) { nextAncDepth = nextDepNode->getAppropriateIndividualNode()->getIndividualAncestorDepth(); } if (!depSet->contains(CDepthDependencyPair(ancDepth,prevDepTrackPoint))) { depSet->insert(CDepthDependencyPair(ancDepth,prevDepTrackPoint)); depList->append(CDepthDependencyPair(ancDepth,prevDepTrackPoint)); } } } return true; } bool CSatisfiableExpanderCacheHandler::hasDependencyToAncestor(CIndividualProcessNode* individualNode, CDependencyTrackPoint* depTrackPoint, bool* branchedFlag, CCalculationAlgorithmContext* calcAlgContext) { cint64 ancDepth = individualNode->getIndividualAncestorDepth(); bool dependencyToAncestor = false; if (ancDepth <= 0) { dependencyToAncestor = depTrackPoint->isPointingToIndependentDependencyNode(); } else { CDependencyNode* depNode = depTrackPoint->getDependencyNode(); if (depNode->hasAppropriateIndividualNode()) { CIndividualProcessNode* appIndiNode = depNode->getAppropriateIndividualNode(); cint64 appIndiAncDepth = appIndiNode->getIndividualAncestorDepth(); dependencyToAncestor = appIndiAncDepth < ancDepth; } else { CDependencyNode::DEPENDENCNODEYTYPE depType = depNode->getDependencyType(); if (depType == CDependencyNode::DNTMERGEDCONCEPT) { dependencyToAncestor = hasDependencyToAncestor(individualNode,depNode->getPreviousDependencyTrackPoint(),branchedFlag,calcAlgContext); } } } if (!dependencyToAncestor && branchedFlag) { if (!depTrackPoint->isPointingToDeterministicDependencyNode()) { *branchedFlag = true; } } return dependencyToAncestor; } }; // end namespace Algorithm }; // end namespace Kernel }; // end namespace Reasoner }; // end namespace Konclude