/*
* 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 "CCompletionGraphCacheHandler.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CCompletionGraphCacheHandler::CCompletionGraphCacheHandler(CIndividualNodeBackendCacheHandler* backendCacheHandler) {
mLastOntology = nullptr;
mLastLoadedCachedCompletionGraph = false;
mPreviousConsistencyCachedCompletionGraph = false;
mLastConfig = nullptr;
mBackendCacheHandler = backendCacheHandler;
}
CCompletionGraphCacheHandler::~CCompletionGraphCacheHandler() {
}
bool CCompletionGraphCacheHandler::loadConsistenceModelData(CCalculationAlgorithmContext* calcAlgContext) {
CConcreteOntology* ontology = calcAlgContext->getProcessingDataBox()->getOntology();
mCalcTask = calcAlgContext->getUsedSatisfiableCalculationTask();
mIndiProcNodeVec = mCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
CConfiguration* config = calcAlgContext->getSatisfiableCalculationTask()->getCalculationConfiguration();
if (mLastOntology != ontology || mLastConfig != config) {
mLastOntology = ontology;
mLastConfig = config;
mIncrementalExpansionCaching = false;
mLastLoadedCachedCompletionGraph = false;
mPreviousConsistencyCachedCompletionGraph = false;
mCurrentIncrementalExpansionID = 0;
CConsistence* consistence = ontology->getConsistence();
if (consistence) {
CConsistenceData* consData = consistence->getConsistenceModelData();
if (consData) {
CConsistenceTaskData* consTaskData = dynamic_cast(consData);
if (consTaskData) {
mDetSatCalcTask = consTaskData->getDeterministicSatisfiableTask();
mCompGraphCachedCalcTask = consTaskData->getCompletionGraphCachedSatisfiableTask();
if (mDetSatCalcTask && mCompGraphCachedCalcTask) {
mDetSatProcNodeVec = mDetSatCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
mCompGraphCachedProcNodeVec = mCompGraphCachedCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
mLastLoadedCachedCompletionGraph = true;
mDetLocalizationTag = mDetSatCalcTask->getProcessingDataBox()->getProcessContext()->getProcessTagger()->getCurrentLocalizationTag();
}
}
}
}
if (!mLastLoadedCachedCompletionGraph) {
CSatisfiableTaskIncrementalConsistencyTestingAdapter* incConsTestAd = mCalcTask->getSatisfiableTaskIncrementalConsistencyTestingAdapter();
if (incConsTestAd) {
CConcreteOntology* prevConsOntology = incConsTestAd->getPreviousConsistentOntology();
CConsistence* prevConsistence = prevConsOntology->getConsistence();
if (prevConsistence) {
CConsistenceData* prevConsData = prevConsistence->getConsistenceModelData();
if (prevConsData) {
CConsistenceTaskData* prevConsTaskData = dynamic_cast(prevConsData);
if (prevConsTaskData) {
mDetSatCalcTask = prevConsTaskData->getDeterministicSatisfiableTask();
mCompGraphCachedCalcTask = prevConsTaskData->getCompletionGraphCachedSatisfiableTask();
if (mDetSatCalcTask && mCompGraphCachedCalcTask) {
mDetSatProcNodeVec = mDetSatCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
mCompGraphCachedProcNodeVec = mCompGraphCachedCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
mPreviousConsistencyCachedCompletionGraph = true;
mIncrementalExpansionCaching = true;
mCurrentIncrementalExpansionID = mCalcTask->getProcessingDataBox()->getIncrementalExpansionID();
mDetLocalizationTag = mDetSatCalcTask->getProcessingDataBox()->getProcessContext()->getProcessTagger()->getCurrentLocalizationTag();
}
}
}
}
}
}
}
return mLastLoadedCachedCompletionGraph;
}
bool CCompletionGraphCacheHandler::getReactivationIndividuals(CIndividualProcessNode* individualNode, CIndividualReactivationProcessingQueue* reactProcQueue, CCalculationAlgorithmContext* calcAlgContext) {
bool addedReactivationIndi = false;
if (loadConsistenceModelData(calcAlgContext)) {
cint64 indiID = individualNode->getIndividualNodeID();
CIndividualProcessNode* compGraphCachedIndiNode = mCompGraphCachedProcNodeVec->getData(indiID);
CIndividualProcessNode* detCompGraphCachedIndiNode = mDetSatProcNodeVec->getData(indiID);
if (compGraphCachedIndiNode && compGraphCachedIndiNode != detCompGraphCachedIndiNode) {
cint64 detSatIndiCount = mDetSatProcNodeVec->getItemMaxIndex();
CPROCESSINGLIST reactivateComplGraphCachedIndiList(calcAlgContext->getTaskProcessorContext());
CPROCESSINGSET reactivateComplGraphCachedIndiSet(calcAlgContext->getTaskProcessorContext());
CIndividualMergingHash* mergingHash = compGraphCachedIndiNode->getIndividualMergingHash(false);
if (mergingHash) {
for (CIndividualMergingHash::const_iterator it = mergingHash->constBegin(), itEnd = mergingHash->constEnd(); it != itEnd; ++it) {
if (it.value().isMergedWithIndividual()) {
cint64 mergedIndiID = it.key();
CIndividualProcessNode* compGraphCachedMergedIndiNode = mCompGraphCachedProcNodeVec->getData(-mergedIndiID);
CIndividualProcessNode* detSatMergedIndiNode = nullptr;
if (-mergedIndiID <= detSatIndiCount) {
detSatMergedIndiNode = mDetSatProcNodeVec->getData(-mergedIndiID);
}
if (compGraphCachedMergedIndiNode != detSatMergedIndiNode && detSatMergedIndiNode) {
addedReactivationIndi |= reactProcQueue->insertReactivationIndiviudal(detSatMergedIndiNode, true);
}
}
}
}
CConnectionSuccessorSetIterator connSuccSetIt(compGraphCachedIndiNode->getConnectionSuccessorIterator());
while (connSuccSetIt.hasNext()) {
cint64 connIndiID = connSuccSetIt.next();
CIndividualProcessNode* detSatConnIndiNode = nullptr;
if (connIndiID <= detSatIndiCount) {
detSatConnIndiNode = mDetSatProcNodeVec->getData(connIndiID);
}
if (detSatConnIndiNode) {
CIndividualProcessNode* compGraphCachedConnIndiNode = mCompGraphCachedProcNodeVec->getData(connIndiID);
if (compGraphCachedConnIndiNode != detSatConnIndiNode) {
addedReactivationIndi |= reactProcQueue->insertReactivationIndiviudal(detSatConnIndiNode,false);
}
} else {
reactivateComplGraphCachedIndiList.append(connIndiID);
reactivateComplGraphCachedIndiSet.insert(connIndiID);
}
}
while (!reactivateComplGraphCachedIndiList.isEmpty()) {
cint64 connIndiID = reactivateComplGraphCachedIndiList.takeFirst();
CIndividualProcessNode* detSatConnIndiNode = nullptr;
if (connIndiID <= detSatIndiCount) {
detSatConnIndiNode = mDetSatProcNodeVec->getData(connIndiID);
}
if (!detSatConnIndiNode) {
CIndividualProcessNode* compGraphCachedConnIndiNode = mCompGraphCachedProcNodeVec->getData(connIndiID);
CConnectionSuccessorSetIterator connSuccSetIt(compGraphCachedConnIndiNode->getConnectionSuccessorIterator());
while (connSuccSetIt.hasNext()) {
cint64 connIndiID = connSuccSetIt.next();
if (!reactivateComplGraphCachedIndiSet.contains(connIndiID)) {
reactivateComplGraphCachedIndiSet.insert(connIndiID);
reactivateComplGraphCachedIndiList.append(connIndiID);
}
}
} else {
addedReactivationIndi |= reactProcQueue->insertReactivationIndiviudal(detSatConnIndiNode,true);
}
}
}
}
return addedReactivationIndi;
}
bool CCompletionGraphCacheHandler::isIndividualNodeCompletionGraphConsistenceBlocked(CIndividualProcessNode* individualNode, bool& conceptSetExtended, CCalculationAlgorithmContext* calcAlgContext) {
conceptSetExtended = false;
if (loadConsistenceModelData(calcAlgContext)) {
if (mIncrementalExpansionCaching) {
if (individualNode->getIncrementalExpansionID() >= mCurrentIncrementalExpansionID) {
return false;
}
}
cint64 detSatIndiCount = mDetSatProcNodeVec->getItemMaxIndex();
cint64 indiID = individualNode->getIndividualNodeID();
if (indiID <= detSatIndiCount) {
CIndividualProcessNode* detSatIndiNode = mDetSatProcNodeVec->getData(indiID);
if (detSatIndiNode) {
CIndividualProcessNode* compGraphCachedIndiNode = mCompGraphCachedProcNodeVec->getData(indiID);
while (compGraphCachedIndiNode->getMergedIntoIndividualNodeID() != compGraphCachedIndiNode->getIndividualNodeID()) {
compGraphCachedIndiNode = mCompGraphCachedProcNodeVec->getData(compGraphCachedIndiNode->getMergedIntoIndividualNodeID());
}
if (testCompletionGraphCached(individualNode,detSatIndiNode,compGraphCachedIndiNode,calcAlgContext)) {
conceptSetExtended = testConceptLabelExtended(individualNode,detSatIndiNode,compGraphCachedIndiNode,calcAlgContext);
return true;
}
}
}
}
return false;
}
bool CCompletionGraphCacheHandler::isIndividualNodeCompletionGraphConsistencePresentNonBlocked(CIndividualProcessNode* individualNode, CCalculationAlgorithmContext* calcAlgContext) {
if (loadConsistenceModelData(calcAlgContext)) {
if (mIncrementalExpansionCaching) {
if (individualNode->getIncrementalExpansionID() >= mCurrentIncrementalExpansionID) {
return false;
}
}
cint64 nonDetSatIndiCount = mCompGraphCachedProcNodeVec->getItemMaxIndex();
cint64 indiID = individualNode->getIndividualNodeID();
if (indiID <= nonDetSatIndiCount) {
CIndividualProcessNode* compGraphCachedIndiNode = mCompGraphCachedProcNodeVec->getData(indiID);
if (compGraphCachedIndiNode) {
bool blocked = compGraphCachedIndiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFDIRECTBLOCKED | CIndividualProcessNode::PRFINDIRECTBLOCKED | CIndividualProcessNode::PRFPROCESSINGBLOCKED);
return !blocked;
}
}
}
return false;
}
bool CCompletionGraphCacheHandler::testConceptLabelExtended(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptLabelSet* conSet = individualNode->getReapplyConceptLabelSet(false);
CReapplyConceptLabelSet* detCachedConSet = detSatIndiNode->getReapplyConceptLabelSet(false);
if (conSet->getAddingSortedConceptDescriptionLinker() != detCachedConSet->getAddingSortedConceptDescriptionLinker()) {
return true;
}
return false;
}
bool CCompletionGraphCacheHandler::testCompletionGraphCached(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CCalculationAlgorithmContext* calcAlgContext) {
bool cached = true;
if (cached) {
cached &= testConceptLabelSubSetCompletionGraphCached(individualNode,detSatIndiNode,compGraphCachedIndiNode,calcAlgContext);
}
if (cached) {
cached &= testDistinctSubSetCompletionGraphCached(individualNode,detSatIndiNode,compGraphCachedIndiNode,calcAlgContext);
}
if (cached) {
cached &= testMergingSubSetCompletionGraphCached(individualNode,detSatIndiNode,compGraphCachedIndiNode,calcAlgContext);
}
if (cached) {
cached &= testBindingSubSetCompletionGraphCached(individualNode,detSatIndiNode,compGraphCachedIndiNode,calcAlgContext);
}
return cached;
}
bool CCompletionGraphCacheHandler::testMergingSubSetCompletionGraphCached(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CCalculationAlgorithmContext* calcAlgContext) {
return true;
}
bool CCompletionGraphCacheHandler::testDistinctSubSetCompletionGraphCached(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CCalculationAlgorithmContext* calcAlgContext) {
CDistinctHash* subDistinctHash = individualNode->getDistinctHash(false);
CDistinctHash* superDistinctHash = compGraphCachedIndiNode->getDistinctHash(false);
if (subDistinctHash) {
if (!superDistinctHash) {
return false;
}
for (CDistinctHash::const_iterator it = subDistinctHash->constBegin(), itEnd = subDistinctHash->constEnd(); it != itEnd; ++it) {
cint64 disIndiID = it.key();
if (!superDistinctHash->isIndividualDistinct(disIndiID)) {
return false;
}
}
}
return true;
}
bool CCompletionGraphCacheHandler::testBindingSubSetCompletionGraphCached(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CCalculationAlgorithmContext* calcAlgContext) {
CConceptRepresentativePropagationSetHash* compGraphCachedVarRepBindSetHash = compGraphCachedIndiNode->getConceptRepresentativePropagationSetHash(false);
CConceptPropagationBindingSetHash* compGraphCachedPropBindSetHash = compGraphCachedIndiNode->getConceptPropagationBindingSetHash(false);
CConceptVariableBindingPathSetHash* compGraphCachedVarBindSetHash = compGraphCachedIndiNode->getConceptVariableBindingPathSetHash(false);
CConceptRepresentativePropagationSetHash* indiVarRepBindSetHash = individualNode->getConceptRepresentativePropagationSetHash(false);
CConceptPropagationBindingSetHash* indiPropBindSetHash = individualNode->getConceptPropagationBindingSetHash(false);
CConceptVariableBindingPathSetHash* indiVarBindSetHash = individualNode->getConceptVariableBindingPathSetHash(false);
if (indiVarRepBindSetHash || indiPropBindSetHash || indiVarRepBindSetHash) {
CReapplyConceptLabelSet* subConceptSet = individualNode->getReapplyConceptLabelSet(false);
CReapplyConceptLabelSetIterator subConSetIt = subConceptSet->getConceptLabelSetIterator(true, false, false);
while (subConSetIt.hasValue()) {
CConceptDescriptor* subConDes = subConSetIt.getConceptDescriptor();
CConcept* concept = subConDes->getConcept();
CConceptOperator* conOperator = concept->getConceptOperator();
if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_PROPAGATION_BIND_TYPE)) {
if (indiPropBindSetHash) {
CPropagationBindingSet* indiPropBindSet = indiPropBindSetHash->getPropagationBindingSet(concept, false);
if (indiPropBindSet) {
CPropagationBindingMap* indiPropBindMap = indiPropBindSet->getPropagationBindingMap();
if (!indiPropBindMap->empty()) {
if (!compGraphCachedPropBindSetHash) {
return false;
}
CPropagationBindingSet* compGraphCachedPropBindSet = compGraphCachedPropBindSetHash->getPropagationBindingSet(concept, false);
if (!compGraphCachedPropBindSet) {
return false;
}
CPropagationBindingMap* compGraphCachedPropBindMap = compGraphCachedPropBindSet->getPropagationBindingMap();
if (!indiPropBindMap->isKeySubSetOf(compGraphCachedPropBindMap)) {
return false;
}
}
}
}
}
if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_VARIABLE_BIND_TYPE)) {
if (indiVarBindSetHash) {
CVariableBindingPathSet* indiVarBindSet = indiVarBindSetHash->getVariableBindingPathSet(concept, false);
if (indiVarBindSet) {
CVariableBindingPathMap* indiVarBindMap = indiVarBindSet->getVariableBindingPathMap();
if (!indiVarBindMap->empty()) {
if (!compGraphCachedVarBindSetHash) {
return false;
}
CVariableBindingPathSet* compGraphCachedVarBindSet = compGraphCachedVarBindSetHash->getVariableBindingPathSet(concept, false);
if (!compGraphCachedVarBindSet) {
return false;
}
CVariableBindingPathMap* compGraphCachedVarBindMap = compGraphCachedVarBindSet->getVariableBindingPathMap();
if (!indiVarBindMap->isKeySubSetOf(compGraphCachedVarBindMap)) {
return false;
}
}
}
}
if (indiVarRepBindSetHash) {
CRepresentativePropagationSet* indiVarRepBindSet = indiVarRepBindSetHash->getRepresentativePropagationSet(concept, false);
if (indiVarRepBindSet) {
CRepresentativePropagationMap* indiVarRepBindMap = indiVarRepBindSet->getRepresentativePropagationMap();
if (!indiVarRepBindMap->empty()) {
if (!compGraphCachedVarRepBindSetHash) {
return false;
}
CRepresentativePropagationSet* compGraphCachedVarRepBindSet = compGraphCachedVarRepBindSetHash->getRepresentativePropagationSet(concept, false);
if (!compGraphCachedVarRepBindSet) {
return false;
}
CRepresentativePropagationMap* compGraphCachedVarRepBindMap = compGraphCachedVarRepBindSet->getRepresentativePropagationMap();
if (!indiVarRepBindMap->isKeySubSetOf(compGraphCachedVarRepBindMap)) {
return false;
}
}
}
}
}
subConSetIt.moveNext();
}
}
return true;
}
bool CCompletionGraphCacheHandler::testConceptLabelSubSetCompletionGraphCached(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptLabelSet* subConceptSet = individualNode->getReapplyConceptLabelSet(false);
CReapplyConceptLabelSet* superConceptSet = compGraphCachedIndiNode->getReapplyConceptLabelSet(false);
cint64 subConSetCount = subConceptSet->getConceptCount();
cint64 superConSetCount = superConceptSet->getConceptCount();
if (subConSetCount > superConSetCount) {
return false;
}
if (superConSetCount == 0) {
return true;
}
CReapplyConceptLabelSetIterator subConSetIt = subConceptSet->getConceptLabelSetIterator(true,false,false);
CReapplyConceptLabelSetIterator superConSetIt = superConceptSet->getConceptLabelSetIterator(true,false,false);
CConceptDescriptor* superConDes = superConSetIt.getConceptDescriptor();
cint64 superConTag = superConDes->getConceptTag();
superConSetIt.moveNext();
bool contained = false;
while (subConSetIt.hasValue()) {
CConceptDescriptor* subConDes = subConSetIt.getConceptDescriptor();
cint64 subConTag = subConDes->getConceptTag();
while (superConTag < subConTag) {
if (!superConSetIt.hasValue()) {
return false;
}
if (testCriticalConcept(individualNode,detSatIndiNode,compGraphCachedIndiNode,superConDes,contained,calcAlgContext)) {
return false;
}
contained = false;
superConDes = superConSetIt.getConceptDescriptor();
superConTag = superConDes->getConceptTag();
superConSetIt.moveNext();
}
if (subConTag != superConTag) {
return false;
} else {
if (subConDes->isNegated() != superConDes->isNegated()) {
return false;
}
contained = true;
}
subConSetIt.moveNext();
}
while (superConSetIt.hasValue()) {
if (testCriticalConcept(individualNode,detSatIndiNode,compGraphCachedIndiNode,superConDes,contained,calcAlgContext)) {
return false;
}
contained = false;
superConDes = superConSetIt.getConceptDescriptor();
superConTag = superConDes->getConceptTag();
superConSetIt.moveNext();
}
if (testCriticalConcept(individualNode,detSatIndiNode,compGraphCachedIndiNode,superConDes,contained,calcAlgContext)) {
return false;
}
return true;
}
bool CCompletionGraphCacheHandler::testCriticalConcept(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CConceptDescriptor* conDes, bool containedFlag, CCalculationAlgorithmContext* calcAlgContext) {
CConcept* concept = conDes->getConcept();
bool conNegation = conDes->getNegation();
cint64 opCode = concept->getOperatorCode();
CRole* role = concept->getRole();
CConceptOperator* conOperator = concept->getConceptOperator();
if (!containedFlag) {
if (!conNegation && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_ALL_AQALL_TYPE)) || conNegation && opCode == CCSOME || !conNegation && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_AQAND_TYPE))) {
return testCriticalB2AutomateTransitionOperands(individualNode,detSatIndiNode,compGraphCachedIndiNode,concept, conNegation,calcAlgContext);
}
}
if (!conNegation && opCode == CCATMOST || conNegation && opCode == CCATLEAST) {
// check cardinality
cint64 cardinality = concept->getParameter() - 1*conNegation;
bool nominalIndiNode = individualNode->isNominalIndividualNode();
cint64 updatedCardinality = 0;
CRoleSuccessorLinkIterator succLinkIt = individualNode->getRoleSuccessorLinkIterator(role);
while (updatedCardinality <= cardinality && succLinkIt.hasNext()) {
CIndividualLinkEdge* link = succLinkIt.next();
CSortedNegLinker* opConLinkerIt = concept->getOperandList();
CIndividualProcessNode* succIndi = link->getOppositeIndividual(individualNode);
if (link->isLocalizationTagUpdated(calcAlgContext->getUsedProcessTagger())) {
succIndi = mIndiProcNodeVec->getData(link->getOppositeIndividualID(individualNode));
}
if (nominalIndiNode) {
if (link->getCreatorIndividualID() != individualNode->getIndividualNodeID()) {
if (succIndi->isBlockableIndividual()) {
// requires NN-rule
return true;
}
}
}
if (succIndi->getLocalizationTag() > mDetLocalizationTag) {
if (succIndi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED | CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID)) {
bool containsSomeOps = true;
if (opConLinkerIt) {
containsSomeOps = false;
while (opConLinkerIt && !containsSomeOps) {
bool opNegated = opConLinkerIt->isNegated() ^ conNegation;
CConcept* opCon = opConLinkerIt->getData();
bool containsNegated = false;
CReapplyConceptLabelSet* succConSet = succIndi->getReapplyConceptLabelSet(false);
if (succConSet) {
if (succConSet->containsConcept(opCon, &containsNegated)) {
if (containsNegated == opNegated) {
containsSomeOps = true;
}
} else {
containsSomeOps = true;
}
}
opConLinkerIt = opConLinkerIt->getNext();
}
if (containsSomeOps) {
CIndividualProcessNode* corrCachedSuccIndi = mCompGraphCachedProcNodeVec->getData(succIndi->getIndividualNodeID());
if (!corrCachedSuccIndi || corrCachedSuccIndi->getMergedIntoIndividualNodeID() != succIndi->getIndividualNodeID() || corrCachedSuccIndi->getLastMergedIntoIndividualNode() != succIndi->getLastMergedIntoIndividualNode()) {
++updatedCardinality;
}
}
}
}
}
}
if (updatedCardinality > cardinality) {
return true;
}
CReapplyRoleSuccessorHash* cachedSuccHash = compGraphCachedIndiNode->getReapplyRoleSuccessorHash(false);
if (cachedSuccHash) {
cint64 linkCount = 0;
CRoleSuccessorLinkIterator succLinkIt = cachedSuccHash->getRoleSuccessorLinkIterator(role, &linkCount);
// check whether some links are lazily expanded from backend cache
if (individualNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION)) {
visitMergedIndividualsBackendSynchronisationData(individualNode, [&](CIndividualProcessNode* baseIndiNode, CIndividualProcessNode* mergedDataIndiNode) -> bool {
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* mergedBackendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)mergedDataIndiNode->getIndividualBackendCacheSynchronisationData(false);
if (mergedBackendSyncData) {
CBackendRepresentativeMemoryCacheIndividualAssociationData* mergedAssocData = mergedBackendSyncData->getAssocitaionData();
mBackendCacheHandler->visitNeighbourIndividualIdsForRole(mergedAssocData, role, [&](cint64 neighbourIndividualId, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, bool nondeterministic)->bool {
CIndividualProcessNode* neighbourIndiNode = mIndiProcNodeVec->getData(-neighbourIndividualId);
while (neighbourIndiNode->getMergedIntoIndividualNodeID() != neighbourIndiNode->getIndividualNodeID()) {
neighbourIndiNode = mIndiProcNodeVec->getData(neighbourIndiNode->getMergedIntoIndividualNodeID());
}
if (!neighbourIndiNode || neighbourIndiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED | CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID)) {
CIndividualProcessNode* neighbourCompCachedIndiNode = mCompGraphCachedProcNodeVec->getData(-neighbourIndividualId);
while (neighbourCompCachedIndiNode && neighbourCompCachedIndiNode->getMergedIntoIndividualNodeID() != neighbourCompCachedIndiNode->getIndividualNodeID()) {
neighbourCompCachedIndiNode = mCompGraphCachedProcNodeVec->getData(neighbourCompCachedIndiNode->getMergedIntoIndividualNodeID());
}
if (neighbourCompCachedIndiNode && compGraphCachedIndiNode->hasRoleSuccessorToIndividual(role, neighbourCompCachedIndiNode, false)) {
bool containsSomeOps = true;
CSortedNegLinker* opConLinkerIt = concept->getOperandList();
if (opConLinkerIt) {
containsSomeOps = false;
while (opConLinkerIt && !containsSomeOps) {
bool opNegated = opConLinkerIt->isNegated();
CConcept* opCon = opConLinkerIt->getData();
CReapplyConceptLabelSet* succConSet = neighbourCompCachedIndiNode->getReapplyConceptLabelSet(false);
if (succConSet && succConSet->containsConcept(opCon, opNegated)) {
containsSomeOps = true;
}
opConLinkerIt = opConLinkerIt->getNext();
}
}
if (containsSomeOps && !neighbourIndiNode || !individualNode->hasRoleSuccessorToIndividual(role, neighbourIndiNode, false)) {
++updatedCardinality;
}
}
}
return updatedCardinality <= cardinality;
}, true, calcAlgContext);
}
return updatedCardinality <= cardinality;
}, calcAlgContext);
if (updatedCardinality > cardinality) {
return true;
}
}
if (cardinality - linkCount < updatedCardinality) {
cint64 cachedCardinality = 0;
while (succLinkIt.hasNext()) {
CIndividualLinkEdge* link = succLinkIt.next();
CSortedNegLinker* opConLinkerIt = concept->getOperandList();
if (!opConLinkerIt) {
++cachedCardinality;
} else {
CIndividualProcessNode* succIndi = link->getOppositeIndividual(individualNode);
if (link->isLocalizationTagUpdated(mCompGraphCachedCalcTask->getProcessingDataBox()->getProcessContext()->getUsedProcessTagger())) {
succIndi = mCompGraphCachedProcNodeVec->getData(link->getOppositeIndividualID(individualNode));
}
bool containsSomeOps = false;
while (opConLinkerIt && !containsSomeOps) {
bool opNegated = opConLinkerIt->isNegated();
CConcept* opCon = opConLinkerIt->getData();
CReapplyConceptLabelSet* succConSet = succIndi->getReapplyConceptLabelSet(false);
if (succConSet && succConSet->containsConcept(opCon,opNegated)) {
containsSomeOps = true;
}
opConLinkerIt = opConLinkerIt->getNext();
}
if (containsSomeOps) {
++cachedCardinality;
}
}
if (updatedCardinality + cachedCardinality > cardinality) {
return true;
}
}
}
}
}
return false;
}
bool CCompletionGraphCacheHandler::visitMergedIndividualsBackendSynchronisationData(CIndividualProcessNode* indiNode, function visitFunc, CCalculationAlgorithmContext* calcAlgContext) {
bool visited = false;
bool continueVisiting = true;
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* backendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)indiNode->getIndividualBackendCacheSynchronisationData(false);
if (backendSyncData) {
continueVisiting = visitFunc(indiNode, indiNode);
visited = true;
}
CBackendRepresentativeMemoryCacheIndividualAssociationData* assocData = backendSyncData->getAssocitaionData();
CBackendRepresentativeMemoryLabelCacheItem* detSameIndiLabel = assocData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_SAME_INDIVIDUAL_SET_LABEL);
CIndividualMergingHash* mergingHash = indiNode->getIndividualMergingHash(false);
if (mergingHash) {
for (CXLinker* newIndiMergedLinkerIt = mergingHash->getMergedIndividualLinker(); newIndiMergedLinkerIt && continueVisiting; newIndiMergedLinkerIt = newIndiMergedLinkerIt->getNext()) {
cint64 newIndiMergedId = newIndiMergedLinkerIt->getData();
if (!mBackendCacheHandler->hasIndividualIdsInAssociatedIndividualSetLabel(assocData, detSameIndiLabel, newIndiMergedId)) {
CIndividualProcessNode* backendSyncDataIndiNode = mIndiProcNodeVec->getData(-newIndiMergedId);
if (backendSyncDataIndiNode->getIndividualBackendCacheSynchronisationData(false)) {
continueVisiting = visitFunc(indiNode, backendSyncDataIndiNode);
visited = true;
}
}
}
}
return visited;
}
bool CCompletionGraphCacheHandler::testCriticalB2AutomateTransitionOperands(CIndividualProcessNode* individualNode, CIndividualProcessNode* detSatIndiNode, CIndividualProcessNode* compGraphCachedIndiNode, CConcept* concept, bool conNegation, CCalculationAlgorithmContext* calcAlgContext) {
cint64 opCode = concept->getOperatorCode();
CConceptOperator* conOperator = concept->getConceptOperator();
if (!conNegation && conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_AQAND_TYPE)) {
// recursive
CSortedNegLinker* opLinkerIt = concept->getOperandList();
while (opLinkerIt) {
CConcept* opConcept = opLinkerIt->getData();
if (testCriticalB2AutomateTransitionOperands(individualNode,detSatIndiNode,compGraphCachedIndiNode,opConcept, opLinkerIt->isNegated() ^ conNegation,calcAlgContext)) {
return true;
}
opLinkerIt = opLinkerIt->getNext();
}
} else if (!conNegation && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_ALL_AQALL_TYPE)) || conNegation && opCode == CCSOME) {
CRole* conRole = concept->getRole();
CRoleSuccessorLinkIterator succLinkIt = individualNode->getRoleSuccessorLinkIterator(conRole);
while (succLinkIt.hasNext()) {
CIndividualLinkEdge* link = succLinkIt.next();
CIndividualProcessNode* succIndi = link->getOppositeIndividual(individualNode);
if (link->isLocalizationTagUpdated(calcAlgContext->getUsedProcessTagger())) {
succIndi = mIndiProcNodeVec->getData(link->getOppositeIndividualID(individualNode));
}
if (succIndi->getLocalizationTag() > mDetLocalizationTag && !succIndi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHED)
|| succIndi->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED | CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID)) {
return checkPropagatedConceptsMissing(concept, conNegation, succIndi, conOperator, compGraphCachedIndiNode);
}
}
if (individualNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION)) {
bool criticalMissingLink = false;
visitMergedIndividualsBackendSynchronisationData(individualNode, [&](CIndividualProcessNode* baseIndiNode, CIndividualProcessNode* mergedDataIndiNode) -> bool {
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* mergedBackendSyncData = (CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData*)mergedDataIndiNode->getIndividualBackendCacheSynchronisationData(false);
if (mergedBackendSyncData) {
CBackendRepresentativeMemoryCacheIndividualAssociationData* mergedAssocData = mergedBackendSyncData->getAssocitaionData();
mBackendCacheHandler->visitNeighbourIndividualIdsForRole(mergedAssocData, conRole, [&](cint64 neighbourIndividualId, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, bool nondeterministic)->bool {
CIndividualProcessNode* neighbourIndiNode = mIndiProcNodeVec->getData(-neighbourIndividualId);
while (neighbourIndiNode && neighbourIndiNode->getMergedIntoIndividualNodeID() != neighbourIndiNode->getIndividualNodeID()) {
neighbourIndiNode = mIndiProcNodeVec->getData(neighbourIndiNode->getMergedIntoIndividualNodeID());
}
if (!neighbourIndiNode || neighbourIndiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED | CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID)) {
CIndividualProcessNode* neighbourCompCachedIndiNode = mCompGraphCachedProcNodeVec->getData(-neighbourIndividualId);
while (neighbourCompCachedIndiNode && neighbourCompCachedIndiNode->getMergedIntoIndividualNodeID() != neighbourCompCachedIndiNode->getIndividualNodeID()) {
neighbourCompCachedIndiNode = mCompGraphCachedProcNodeVec->getData(neighbourCompCachedIndiNode->getMergedIntoIndividualNodeID());
}
if (neighbourCompCachedIndiNode && compGraphCachedIndiNode->hasRoleSuccessorToIndividual(conRole, neighbourCompCachedIndiNode, false)) {
if (!neighbourIndiNode) {
criticalMissingLink = true;
} else if (!individualNode->hasRoleSuccessorToIndividual(conRole, neighbourIndiNode, false)) {
if (checkPropagatedConceptsMissing(concept, conNegation, neighbourIndiNode, conOperator, neighbourCompCachedIndiNode)) {
criticalMissingLink = true;
}
}
}
}
return !criticalMissingLink;
}, true, calcAlgContext);
}
return !criticalMissingLink;
}, calcAlgContext);
if (criticalMissingLink) {
return true;
}
}
}
return true;
}
bool CCompletionGraphCacheHandler::checkPropagatedConceptsMissing(CConcept* concept, bool conNegation, CIndividualProcessNode* succIndi, CConceptOperator* conOperator, CIndividualProcessNode* compGraphCachedIndiNode) {
CSortedNegLinker* opConLinkerIt = concept->getOperandList();
while (opConLinkerIt) {
bool opNegated = opConLinkerIt->isNegated() ^ conNegation;
CConcept* opCon = opConLinkerIt->getData();
CReapplyConceptLabelSet* succConSet = succIndi->getReapplyConceptLabelSet(false);
if (!succConSet || !succConSet->containsConcept(opCon, opNegated)) {
return true;
}
if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCF_PBINDAQALL | CConceptOperator::CCF_PBINDALL)) {
CConceptPropagationBindingSetHash* compGraphCachedPropBindSetHash = compGraphCachedIndiNode->getConceptPropagationBindingSetHash(false);
if (compGraphCachedPropBindSetHash) {
CPropagationBindingSet* compGraphCachedPropBindSet = compGraphCachedPropBindSetHash->getPropagationBindingSet(concept, false);
if (compGraphCachedPropBindSet) {
CPropagationBindingMap* compGraphCachedPropBindMap = compGraphCachedPropBindSet->getPropagationBindingMap();
if (!compGraphCachedPropBindMap->empty()) {
CConceptPropagationBindingSetHash* succPropBindSetHash = succIndi->getConceptPropagationBindingSetHash(false);
if (!succPropBindSetHash) {
return true;
}
CPropagationBindingSet* succPropBindSet = succPropBindSetHash->getPropagationBindingSet(opCon, false);
if (!succPropBindSet) {
return true;
}
CPropagationBindingMap* succPropBindMap = succPropBindSet->getPropagationBindingMap();
if (!compGraphCachedPropBindMap->isKeySubSetOf(succPropBindMap)) {
return true;
}
}
}
}
}
if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCF_VARBINDAQALL | CConceptOperator::CCF_VARBINDALL)) {
CConceptVariableBindingPathSetHash* compGraphCachedVarBindSetHash = compGraphCachedIndiNode->getConceptVariableBindingPathSetHash(false);
if (compGraphCachedVarBindSetHash) {
CVariableBindingPathSet* compGraphCachedVarBindSet = compGraphCachedVarBindSetHash->getVariableBindingPathSet(concept, false);
if (compGraphCachedVarBindSet) {
CVariableBindingPathMap* compGraphCachedVarBindMap = compGraphCachedVarBindSet->getVariableBindingPathMap();
if (!compGraphCachedVarBindMap->empty()) {
CConceptVariableBindingPathSetHash* succVarBindSetHash = succIndi->getConceptVariableBindingPathSetHash(false);
if (!succVarBindSetHash) {
return true;
}
CVariableBindingPathSet* succVarBindSet = succVarBindSetHash->getVariableBindingPathSet(opCon, false);
if (!succVarBindSet) {
return true;
}
CVariableBindingPathMap* succVarBindMap = succVarBindSet->getVariableBindingPathMap();
if (!compGraphCachedVarBindMap->isKeySubSetOf(succVarBindMap)) {
return true;
}
}
}
}
CConceptRepresentativePropagationSetHash* compGraphCachedVarRepBindSetHash = compGraphCachedIndiNode->getConceptRepresentativePropagationSetHash(false);
if (compGraphCachedVarRepBindSetHash) {
CRepresentativePropagationSet* compGraphCachedVarRepBindSet = compGraphCachedVarRepBindSetHash->getRepresentativePropagationSet(concept, false);
if (compGraphCachedVarRepBindSet) {
CRepresentativePropagationMap* compGraphCachedVarRepBindMap = compGraphCachedVarRepBindSet->getRepresentativePropagationMap();
if (!compGraphCachedVarRepBindMap->empty()) {
CConceptRepresentativePropagationSetHash* succVarRepBindSetHash = succIndi->getConceptRepresentativePropagationSetHash(false);
if (!succVarRepBindSetHash) {
return true;
}
CRepresentativePropagationSet* succVarRepBindSet = succVarRepBindSetHash->getRepresentativePropagationSet(opCon, false);
if (!succVarRepBindSet) {
return true;
}
CRepresentativePropagationMap* succVarRepBindMap = succVarRepBindSet->getRepresentativePropagationMap();
if (!compGraphCachedVarRepBindMap->isKeySubSetOf(succVarRepBindMap)) {
return true;
}
}
}
}
}
opConLinkerIt = opConLinkerIt->getNext();
}
return false;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude