/*
* 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 "CIncrementalPrecomputationThread.h"
#ifndef KONCLUDE_FORCE_STATISTIC_DEACTIVATED
#define KONCLUDE_PRECOMPUTATION_SATURATION_STATISTIC_OUTPUT
#endif
namespace Konclude {
namespace Reasoner {
namespace Consistiser {
CIncrementalPrecomputationThread::CIncrementalPrecomputationThread(CReasonerManager *reasonerManager) : CPrecomputationThread(reasonerManager),CLogIdentifier("::Konclude::Reasoner::Kernel::Precomputator",this) {
mReuseCompletionGraphCacheWriter = nullptr;
CCompletionGraphCache* complGraphCache = reasonerManager->getCompletionGraphCache();
if (complGraphCache) {
CReuseCompletionGraphCache* reuseComplGraphCache = dynamic_cast(complGraphCache);
if (reuseComplGraphCache) {
mReuseCompletionGraphCacheWriter = reuseComplGraphCache->createCacheWriter();
}
}
mBackendAssocCache = nullptr;
CBackendCache* backendCache = reasonerManager->getBackendAssociationCache();
if (backendCache) {
mBackendAssocCache = dynamic_cast(backendCache);
}
}
CIncrementalPrecomputationThread::~CIncrementalPrecomputationThread() {
}
COntologyPrecomputationItem* CIncrementalPrecomputationThread::initializeOntologyPrecomputionItem(CConcreteOntology* ontology, CConfigurationBase* config) {
CIncrementalOntologyPrecomputationItem* item = new CIncrementalOntologyPrecomputationItem();
item->initTotallyPrecomputationItem(ontology,config);
if (config) {
bool configErrorFlag = false;
cint64 processorCount = 1;
QString processorCountString = CConfigDataReader::readConfigString(config,"Konclude.Calculation.ProcessorCount",QString(),&configErrorFlag);
if (!configErrorFlag) {
if (processorCountString == "AUTO") {
processorCount = CThread::idealThreadCount();
} else {
qint64 convertedWorkerCount = processorCountString.toInt(&configErrorFlag);
if (configErrorFlag) {
processorCount = convertedWorkerCount;
}
}
}
bool mulConfigErrorFlag = false;
cint64 multiplicator = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Precomputation.TotalPrecomputor.MultipliedUnitsParallelCalculationCount",1,&mulConfigErrorFlag);
mConfMaxTestParallelCount = processorCount*multiplicator;
bool maxConfigErrorFlag = false;
cint64 maxParallel = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Precomputation.TotalPrecomputor.MaximumParallelCalculationCount",1,&maxConfigErrorFlag);
if (!maxConfigErrorFlag) {
if (!mulConfigErrorFlag) {
mConfMaxTestParallelCount = qMin(mConfMaxTestParallelCount,maxParallel);
} else {
mConfMaxTestParallelCount = maxParallel;
}
}
} else {
mConfMaxTestParallelCount = 1;
}
return item;
}
bool CIncrementalPrecomputationThread::createNextTest() {
COntologyPrecomputationItem* loopOntPreCompItem = 0;
bool workTestCreated = false;
while (!workTestCreated && !mProcessingOntItemList.isEmpty()) {
COntologyPrecomputationItem* ontPreCompItem = mProcessingOntItemList.first();
if (ontPreCompItem == loopOntPreCompItem) {
// don't run into infinite loop without doing something
break;
}
CIncrementalOntologyPrecomputationItem* incPreCompItem = (CIncrementalOntologyPrecomputationItem*)ontPreCompItem;
bool failDebug = false;
if (!workTestCreated && incPreCompItem->isConsistenceStepRequired()) {
if (!incPreCompItem->isConsistenceStepFinished()) {
if (incPreCompItem->areConsistenceStepProcessingRequirementSatisfied()) {
if (!failDebug && !incPreCompItem->hasConsistenceCheckCreated()) {
LOG(INFO,getLogDomain(),logTr("Incrementally precompute ontology consistency."),this);
incPreCompItem->setConsistenceCheckCreated(true);
workTestCreated = createConsistencePrecomputationCheck(incPreCompItem);
}
if (incPreCompItem->hasConsistenceCheched()) {
incPreCompItem->getConsistencePrecomputationStep()->setStepFinished(true);
if (incPreCompItem->getOntology()->getConsistence()->isOntologyConsistent()) {
incPreCompItem->getConsistencePrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSSUCESSFULL);
} else {
incPreCompItem->getConsistencePrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSSUCESSFULL | COntologyProcessingStatus::PSINCONSITENT);
}
}
} else {
incPreCompItem->getConsistencePrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSFAILED | COntologyProcessingStatus::PSFAILEDREQUIREMENT);
incPreCompItem->getConsistencePrecomputationStep()->setStepFinished(true);
}
} else {
incPreCompItem->getConsistencePrecomputationStep()->submitRequirementsUpdate();
}
}
if (!workTestCreated && incPreCompItem->isIndividualStepRequired() && incPreCompItem->isConsistenceStepFinished()) {
if (!incPreCompItem->isIndividualStepFinished()) {
if (incPreCompItem->areIndividualStepProcessingRequirementSatisfied()) {
if (!incPreCompItem->hasIndividualPrecomputationCreated()) {
incPreCompItem->setIndividualPrecomputationCreated(true);
workTestCreated = createIndividualPrecomputationCheck(incPreCompItem);
}
if (incPreCompItem->hasIndividualPrecomputationChecked() && !incPreCompItem->isIndividualComputationRunning()) {
incPreCompItem->setIndividualStepRunning(false);
incPreCompItem->getIndividualPrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSSUCESSFULL);
incPreCompItem->getIndividualPrecomputationStep()->setStepFinished(true);
}
} else {
incPreCompItem->setIndividualStepRunning(false);
incPreCompItem->getIndividualPrecomputationStep()->setStepFinished(true);
incPreCompItem->getIndividualPrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSFAILED | COntologyProcessingStatus::PSFAILEDREQUIREMENT);
}
} else {
incPreCompItem->getIndividualPrecomputationStep()->submitRequirementsUpdate();
}
}
if (!workTestCreated && incPreCompItem->isSaturationStepRequired() && incPreCompItem->isConsistenceStepFinished() && incPreCompItem->isIndividualStepFinished()) {
if (!incPreCompItem->isSaturationStepFinished()) {
if (incPreCompItem->areSaturationStepProcessingRequirementSatisfied()) {
incPreCompItem->getSaturationPrecomputationStep()->setStepFinished(true);
incPreCompItem->getSaturationPrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSSUCESSFULL);
} else {
incPreCompItem->getSaturationPrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSFAILED | COntologyProcessingStatus::PSFAILEDREQUIREMENT);
}
} else {
incPreCompItem->getSaturationPrecomputationStep()->submitRequirementsUpdate();
}
}
if (!workTestCreated && incPreCompItem->isCycleStepRequired() && incPreCompItem->isConsistenceStepFinished()) {
if (!incPreCompItem->isCycleStepFinished()) {
if (incPreCompItem->areCycleStepProcessingRequirementSatisfied()) {
incPreCompItem->getCyclePrecomputationStep()->setStepFinished(true);
incPreCompItem->getCyclePrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSSUCESSFULL);
} else {
incPreCompItem->getCyclePrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSFAILED | COntologyProcessingStatus::PSFAILEDREQUIREMENT);
incPreCompItem->getCyclePrecomputationStep()->setStepFinished(true);
}
} else {
incPreCompItem->getCyclePrecomputationStep()->submitRequirementsUpdate();
}
}
if (!workTestCreated) {
if (!incPreCompItem->hasRemainingProcessingRequirements()) {
finishOntologyPrecomputation(incPreCompItem);
mProcessingOntItemList.removeFirst();
} else {
mProcessingOntItemList.removeFirst();
mProcessingOntItemList.append(incPreCompItem);
loopOntPreCompItem = ontPreCompItem;
}
}
}
return workTestCreated;
}
bool CIncrementalPrecomputationThread::createIndividualPrecomputationCheck(CIncrementalOntologyPrecomputationItem* incPreCompItem) {
CConcreteOntology* onto = incPreCompItem->getOntology();
CSatisfiableCalculationJob* satCalcJob = nullptr;
return false;
}
QSet* CIncrementalPrecomputationThread::getDirectlyChangedIndividualsFromLastConsistentlyTestedOntology(CIncrementalOntologyPrecomputationItem* incPreCompItem) {
CConcreteOntology* lastConOntVer = getLastConsistentlyTestedOntologyVersion(incPreCompItem);
return getDirectlyChangedIndividuals(lastConOntVer,incPreCompItem);
}
QSet* CIncrementalPrecomputationThread::getDirectlyChangedIndividuals(CConcreteOntology* lastOntologyVersion, CIncrementalOntologyPrecomputationItem* incPreCompItem) {
QSet* indiSet = incPreCompItem->getDirectlyChangedIndividualSet();
if (!incPreCompItem->hasDirectlyChangedIndividualsIdentified()) {
CConcreteOntology* ontology = incPreCompItem->getOntology();
CIndividualVector* indiVec = ontology->getABox()->getIndividualVector(false);
if (indiVec) {
cint64 indiCount = indiVec->getItemCount();
CIndividualVector* prevIndiVec = lastOntologyVersion->getABox()->getIndividualVector(false);
if (!prevIndiVec) {
for (cint64 i = 0; i < indiCount; ++i) {
CIndividual* individual = indiVec->getData(i);
if (individual) {
indiSet->insert(individual);
}
}
} else {
for (cint64 i = 0; i < indiCount; ++i) {
CIndividual* individual = indiVec->getData(i);
if (individual) {
CIndividual* prevIndividual = prevIndiVec->getData(i);
if (individual != prevIndividual) {
indiSet->insert(individual);
}
}
}
}
}
incPreCompItem->setDirectlyChangedIndividualsIdentified(true);
}
return indiSet;
}
CConcreteOntology* CIncrementalPrecomputationThread::getLastConsistentlyTestedOntologyVersion(CIncrementalOntologyPrecomputationItem* incPreCompItem) {
CConcreteOntology* lastConsOntology = incPreCompItem->getLastConsistentlyTestedVersion();
if (!lastConsOntology) {
CConcreteOntology* ontology = incPreCompItem->getOntology();
CConcreteOntology* prevOntology = ontology->getIncrementalRevisionData()->getPreviousOntologyVersion();
while (prevOntology && !lastConsOntology) {
CConsistence* prevConsistenceData = prevOntology->getConsistence();
if (prevConsistenceData && prevConsistenceData->isOntologyConsistent()) {
if (prevConsistenceData->areAllIndividualsRepresentativelyStored() || prevConsistenceData->hasConsistenceModelData()) {
lastConsOntology = prevOntology;
}
}
if (!lastConsOntology) {
prevOntology = prevOntology->getIncrementalRevisionData()->getPreviousOntologyVersion();
}
}
incPreCompItem->setLastConsistentlyTestedVersion(lastConsOntology);
}
return lastConsOntology;
}
bool CIncrementalPrecomputationThread::createConsistencePrecomputationCheck(CIncrementalOntologyPrecomputationItem* incPreCompItem) {
CConcreteOntology* onto = incPreCompItem->getOntology();
CSatisfiableCalculationJob* satCalcJob = nullptr;
CConcreteOntology* lastConsistentlyTestedOnto = getLastConsistentlyTestedOntologyVersion(incPreCompItem);
CIndividualVector* indiVec = onto->getABox()->getIndividualVector(false);
cint64 indiCount = 0;
if (indiVec) {
indiCount = indiVec->getItemCount();
}
bool consistencyDetected = false;
bool detectedConsistency = true;
if (false) {
consistencyDetected = true;
detectedConsistency = true;
LOG(INFO,getLogDomain(),logTr("Trivial consistency detected with merged individual."),getLogObject());
} else {
QSet* changedIndividualSet = getDirectlyChangedIndividuals(lastConsistentlyTestedOnto,incPreCompItem);
QList indiList;
for (QSet::const_iterator it = changedIndividualSet->constBegin(), itEnd = changedIndividualSet->constEnd(); it != itEnd; ++it) {
CIndividual* individual(*it);
indiList.append(individual);
}
CSatisfiableCalculationJobGenerator satCalcJobGen(onto);
if (indiList.isEmpty()) {
CConcept* topConcept = onto->getTBox()->getTopConcept();
if (topConcept->getOperandCount() > 0) {
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(topConcept);
} else {
consistencyDetected = true;
detectedConsistency = true;
}
} else {
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(indiList);
}
}
CConsistence* consistence = onto->getConsistence();
if (!consistence) {
consistence = new CConsistence();
onto->setConsistence(consistence);
}
incPreCompItem->setConsistence(consistence);
if (consistencyDetected) {
consistence->setOntologyConsistent(detectedConsistency);
incPreCompItem->setConsistenceCheched(true);
return false;
} else {
cint64 incRevID = incPreCompItem->getIncrementalExpansionID();
CIncrementalConsistencePrecomputationTestingItem* consTestItem = new CIncrementalConsistencePrecomputationTestingItem(incPreCompItem,lastConsistentlyTestedOnto,incRevID,incPreCompItem);
CCalculationConfigurationExtension* calcConfig = incPreCompItem->getCalculationConfiguration();
satCalcJob->setCalculationConfiguration(calcConfig);
satCalcJob->setSatisfiableTaskIncrementalConsistencyTestingAdapter(consTestItem->getIncrementalConsistencyTestingAdapter());
processCalculationJob(satCalcJob,incPreCompItem,consTestItem);
return true;
}
}
bool CIncrementalPrecomputationThread::precomputationIndividualsRetrieved(COntologyPrecomputationItem* ontPreCompItem, CRetrievedPrecomputationIndividualsCallbackEvent* pcce) {
return false;
}
bool CIncrementalPrecomputationThread::precomputationTested(COntologyPrecomputationItem* ontPreCompItem, CPrecomputationTestingItem* preTestItem, CSaturationPrecomputationCalculatedCallbackEvent* pcce) {
return false;
}
bool CIncrementalPrecomputationThread::precomputationTested(COntologyPrecomputationItem* ontPreCompItem, CPrecomputationTestingItem* preTestItem, CPrecomputationCalculatedCallbackEvent* pcce) {
CIncrementalOntologyPrecomputationItem* incPreCompItem = (CIncrementalOntologyPrecomputationItem*)ontPreCompItem;
if (preTestItem->getPrecomputationTestingType() == CPrecomputationTestingItem::CONSISTENCEPRECOMPUTATIONTYPE) {
CIncrementalConsistencePrecomputationTestingItem* consPreTestItem = (CIncrementalConsistencePrecomputationTestingItem*)preTestItem;
incPreCompItem->setIndividualStepRunning(false);
incPreCompItem->setIndividualPrecomputationChecked(true);
incPreCompItem->setConsistenceCheched(true);
if (pcce->hasCalculationError()) {
LOG(ERROR,getLogDomain(),logTr("Error in computation, consistence testing for ontology '%1' failed.").arg(ontPreCompItem->getOntology()->getTerminologyName()),getLogObject());
incPreCompItem->getConsistencePrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSFAILED);
incPreCompItem->getIndividualPrecomputationStep()->submitRequirementsUpdate(COntologyProcessingStatus::PSFAILED);
} else {
CConsistence* consistence = incPreCompItem->getConsistence();
consistence->setConsistenceModelData(incPreCompItem->getConsistenceData());
consistence->setOntologyConsistent(pcce->getTestResultSatisfiable());
}
logIncrementalReasoningInfos(incPreCompItem);
return true;
}
return false;
}
bool CIncrementalPrecomputationThread::logIncrementalReasoningInfos(CIncrementalOntologyPrecomputationItem* incPreCompItem) {
CConsistenceData* consData = incPreCompItem->getConsistenceData();
if (consData) {
CIncrementalConsistenceTaskData* incConsTaskData = dynamic_cast(consData);
if (incConsTaskData) {
cint64 directlyChangedNodeCount = incPreCompItem->getDirectlyChangedIndividualSet()->count();
cint64 deterministicallyChangedNodeCount = incConsTaskData->getDeterministicallyChangedNodeCount();
cint64 indirectlyChangedNodeCount = incConsTaskData->getIndirectlyChangedCount();
cint64 changedCompatibleNodeCount = incConsTaskData->getChangedCompatibleNodeCount();
COntologyProcessingStatistics* ontProcStats = incPreCompItem->getConsistencePrecomputationStep()->getProcessingStepData()->getProcessingStatistics(true);
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-directly-changed-individual-count",directlyChangedNodeCount);
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-deterministically-changed-node-count",deterministicallyChangedNodeCount);
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-indirectly-changed-node-count",indirectlyChangedNodeCount);
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-changed-compatible-node-count",changedCompatibleNodeCount);
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-added-node-count",incConsTaskData->getAddedNodeCount());
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-new-total-node-count",incConsTaskData->getTotalNodeCount());
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-previous-total-node-count",incConsTaskData->getPreviousNodeCount());
ontProcStats->setProcessingCountStatisticValue("incremental-consistency-checking-time",incPreCompItem->getInitializationTime()->elapsed());
LOG(INFO,getLogDomain(),logTr("Established consistency incrementally, %1 individuals directly changed, %2 nodes deterministically changed, %3 nodes indirectly changed.").arg(directlyChangedNodeCount).arg(deterministicallyChangedNodeCount).arg(indirectlyChangedNodeCount),this);
}
}
return false;
}
bool CIncrementalPrecomputationThread::finishOntologyPrecomputation(CIncrementalOntologyPrecomputationItem* incPreCompItem) {
if (incPreCompItem->areAllStepFinished()) {
incPreCompItem->setPrecomputationFinished(true);
CConcreteOntology* ontology = incPreCompItem->getOntology();
CPrecomputation* precomputation = ontology->getPrecomputation();
precomputation->setPrecomputed(true);
}
incPreCompItem->doPrecomputationFinishedCallback(true);
mActiveOntItemSet.remove(incPreCompItem);
mInactiveOntItemSet.insert(incPreCompItem);
return true;
}
}; // end namespace Consistiser
}; // end namespace Reasoner
}; // end namespace Konclude