/*
* 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 "CReasonerManagerThread.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Manager {
CReasonerManagerThread::CReasonerManagerThread(CWatchDog *threadWatchDog) : CIntervalThread("Reasoner-Manager",threadWatchDog) {
mWatchDog = threadWatchDog;
mCalculationManager = 0;
mPrecomputationManager = 0;
mPreprocessingManager = 0;
mRealizationManager = 0;
mAnswererManager = 0;
}
CReasonerManager *CReasonerManagerThread::initializeManager(CConfigurationProvider *configurationProvider) {
//stopThread();
configProvider = configurationProvider;
classificationMan = CConfigManagerReader::readClassificationManagerConfig(configProvider);
bool configErrorFlag = false;
mWorkControllerCount = 1;
QString workerCountString = CConfigDataReader::readConfigString(configProvider,"Konclude.Calculation.WorkerCount",QString(),&configErrorFlag);
if (!configErrorFlag) {
if (workerCountString == "AUTO") {
mWorkControllerCount = CThread::idealThreadCount();
} else {
qint64 convertedWorkerCount = workerCountString.toInt(&configErrorFlag);
if (configErrorFlag) {
mWorkControllerCount = convertedWorkerCount;
}
}
}
configErrorFlag = false;
cint64 processorCount = 0;
QString processorCountString = CConfigDataReader::readConfigString(configProvider,"Konclude.Calculation.ProcessorCount",QString(),&configErrorFlag);
if (!configErrorFlag) {
if (processorCountString == "AUTO") {
processorCount = CThread::idealThreadCount();
} else {
qint64 convertedWorkerCount = processorCountString.toInt(&configErrorFlag);
if (configErrorFlag) {
processorCount = convertedWorkerCount;
}
}
}
mWorkControllerCount = qMax(processorCount,mWorkControllerCount);
mConfgAdaptThreadPoolToWorkerCount = CConfigDataReader::readConfigBoolean(configProvider, "Konclude.Calculation.AdaptThreadPoolSizeProcessorCount", true);
mBlockThreadPoolThreadCount = CConfigDataReader::readConfigBoolean(configProvider, "Konclude.Calculation.BlockingThreadPoolThreadsCount", 1);
//if (!isRunning()) {
mWatchDog = 0;
unsatCache = 0;
mSatExpCache = 0;
mReuseCompGraphCache = 0;
mSatNodeExpCache = 0;
//}
mPrecomputationManager = new CPrecomputationManager(this);
mPreprocessingManager = new CPreprocessingManager(this);
mRealizationManager = new CRealizationManager(this);
mRequirementExpander = new COntologyProcessingRequirementExpander();
startThread();
return this;
}
CReasonerManagerThread::~CReasonerManagerThread() {
stopThread();
}
CReasonerManager* CReasonerManagerThread::reasoningSatisfiableCalcualtionJob(CSatisfiableCalculationJob* satCalcJob, CCallbackData* callback) {
postEvent(new CReasoningSatisfiableCalculationJobEvent(satCalcJob,callback));
return this;
}
CJobSatisfiableResult* CReasonerManagerThread::reasoningSatisfiableCalcualtionJob(CSatisfiableCalculationJob* satCalcJob) {
CJobSatisfiableCallbackContextData* satCalcData = nullptr;
CBlockingCallbackData callback;
postEvent(new CReasoningSatisfiableCalculationJobEvent(satCalcJob,&callback));
callback.waitForCallback();
satCalcData = (CJobSatisfiableCallbackContextData*)callback.takeCallbackDataContext();
return satCalcData;
}
CReasonerManager *CReasonerManagerThread::reasoningQuery(CQuery *query, CCallbackData *callback) {
postEvent(new CCalcQueryEvent(query,callback));
return this;
}
CReasonerManager *CReasonerManagerThread::reasoningQuery(CQuery *query) {
CBlockingCallbackData callback;
postEvent(new CCalcQueryEvent(query,&callback));
callback.waitForCallback();
return this;
}
CReasonerManager *CReasonerManagerThread::prepareOntology(CConcreteOntology* ontology, const QList& reqList, CCallbackData *callback) {
postEvent(new CPrepareOntologyEvent(ontology,reqList,callback));
return this;
}
CReasonerManager *CReasonerManagerThread::prepareOntology(CConcreteOntology* ontology, const QList& reqList) {
CBlockingCallbackData callback;
postEvent(new CPrepareOntologyEvent(ontology,reqList,&callback));
callback.waitForCallback();
return this;
}
CUnsatisfiableCache *CReasonerManagerThread::getUnsatisfiableCache() {
return unsatCache;
}
CCompletionGraphCache *CReasonerManagerThread::getCompletionGraphCache() {
return mReuseCompGraphCache;
}
CSaturationCache* CReasonerManagerThread::getSaturationAssociationExpansionCache() {
return mSatNodeExpCache;
}
CBackendCache* CReasonerManagerThread::getBackendAssociationCache() {
return mBackendAssCache;
}
COccurrenceStatisticsCache* CReasonerManagerThread::getOccurrenceStatisticsCache() {
return mOccStatsCache;
}
CCalculationManager *CReasonerManagerThread::getCalculationManager() {
return mCalculationManager;
}
CPrecomputationManager* CReasonerManagerThread::getPrecomputationManager() {
return mPrecomputationManager;
}
CPreprocessingManager* CReasonerManagerThread::getPreprocessingManager() {
return mPreprocessingManager;
}
CRealizationManager* CReasonerManagerThread::getRealizationManager() {
return mRealizationManager;
}
void CReasonerManagerThread::readConfig(CConfigurationBase *config) {
}
CTaskHandleAlgorithm *CReasonerManagerThread::createTaskHandleAlgorithm() {
CUnsatisfiableCacheHandler* unsatCacheHandler = nullptr;
CSatisfiableExpanderCacheHandler* satExpCacheHandler = nullptr;
CReuseCompletionGraphCacheHandler* reuseCompGraphCacheHandler = nullptr;
CSaturationNodeExpansionCacheHandler* satNodeCacheHandler = nullptr;
CComputedConsequencesCacheHandler* compConsCachHandler = nullptr;
CSaturationNodeBackendAssociationCacheHandler* backendAssCacheHandler = nullptr;
CIndividualNodeBackendCacheHandler* backendCacheHandler = nullptr;
COccurrenceStatisticsCacheHandler* occStatsCacheHandler = nullptr;
CSatisfiableTaskSaturationOccurrenceStatisticsCollector* satTaskOccStatCollector = nullptr;
if (unsatCache) {
unsatCacheHandler = new CUnsatisfiableCacheHandler(unsatCache->getCacheReader(),unsatCache->getCacheWriter());
}
if (mSatExpCache) {
satExpCacheHandler = new CSatisfiableExpanderCacheHandler(mSatExpCache->createCacheReader(),mSatExpCache->createCacheWriter());
}
if (mReuseCompGraphCache) {
reuseCompGraphCacheHandler = new CReuseCompletionGraphCacheHandler(mReuseCompGraphCache->createCacheReader(),mReuseCompGraphCache->createCacheWriter());
}
if (mSatNodeExpCache) {
satNodeCacheHandler = new CSaturationNodeExpansionCacheHandler(mSatNodeExpCache->createCacheReader(),mSatNodeExpCache->createCacheWriter());
}
if (mCompConsCache) {
compConsCachHandler = new CComputedConsequencesCacheHandler(mCompConsCache->createCacheReader(),mCompConsCache->createCacheWriter());
}
COccurrenceStatisticsCacheWriter* occStatsCacheWriter = nullptr;
if (mOccStatsCache) {
occStatsCacheWriter = mOccStatsCache->createCacheWriter();
satTaskOccStatCollector = new CSatisfiableTaskSaturationOccurrenceStatisticsCollector(occStatsCacheWriter);
occStatsCacheHandler = new COccurrenceStatisticsCacheHandler(occStatsCacheWriter);
}
if (mBackendAssCache) {
CBackendRepresentativeMemoryCacheWriter* backAssCacheWriter = mBackendAssCache->createCacheWriter();
CBackendRepresentativeMemoryCacheReader* backAssCacheReader = mBackendAssCache->createCacheReader();
backendAssCacheHandler = new CSaturationNodeBackendAssociationCacheHandler(backAssCacheReader, backAssCacheWriter, occStatsCacheWriter);
backendCacheHandler = new CIndividualNodeBackendCacheHandler(backAssCacheReader, backAssCacheWriter);
}
CCalculationTableauApproximationSaturationTaskHandleAlgorithm* approxSatHandleAlg = new CCalculationTableauApproximationSaturationTaskHandleAlgorithm(backendAssCacheHandler, satTaskOccStatCollector);
CCalculationTableauCompletionTaskHandleAlgorithm* compTaskHandleAlg = new CCalculationTableauCompletionTaskHandleAlgorithm(unsatCacheHandler,satExpCacheHandler,reuseCompGraphCacheHandler,satNodeCacheHandler,compConsCachHandler,backendCacheHandler, occStatsCacheHandler);
return new CCalculationChooseTaskHandleAlgorithm(compTaskHandleAlg,approxSatHandleAlg);
}
void CReasonerManagerThread::threadStarted() {
CIntervalThread::threadStarted();
// generate worker framework
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Initializing reasoner. Creating calculation context."),this);
if (mConfgAdaptThreadPoolToWorkerCount) {
QThreadPool::globalInstance()->setMaxThreadCount(mWorkControllerCount);
}
if (mBlockThreadPoolThreadCount > 0) {
for (cint64 i = 0; i < mBlockThreadPoolThreadCount; ++i) {
QtConcurrent::run(QThreadPool::globalInstance(), [&]() {
mBlockThreadPoolThreadsBlockingSemaphore.acquire(1);
mBlockThreadPoolThreadsReleasingSemaphore.release(1);
});
}
}
unsatCache = new COccurrenceUnsatisfiableCache(mWorkControllerCount+2);
mSatExpCache = new CSignatureSatisfiableExpanderCache(configProvider->getCurrentConfiguration());
mReuseCompGraphCache = new CReuseCompletionGraphCache();
mSatNodeExpCache = new CSaturationNodeAssociatedExpansionCache(configProvider->getCurrentConfiguration());
mCompConsCache = new CComputedConsequencesCache(configProvider->getCurrentConfiguration());
mBackendAssCache = new CBackendRepresentativeMemoryCache(configProvider->getCurrentConfiguration());
mOccStatsCache = new COccurrenceStatisticsCache(configProvider->getCurrentConfiguration());
CConfigDependedCalculationFactory* calcFactory = new CConfigDependedCalculationFactory(this);
CCalculationManager* calculationManager = calcFactory->createCalculationManager(configProvider);
calcFactory->initializeManager(calculationManager,configProvider);
mCalculationManager = calculationManager;
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Reasoner initialized with %1 processing unit(s).").arg(mWorkControllerCount),this);
startTimerWithInterval(PROGRESSQUERYTIMER,10000);
}
void CReasonerManagerThread::threadStopped() {
CIntervalThread::threadStopped();
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Closing Reasoner."),this);
//QThread::msleep(50);
delete mCalculationManager;
delete mPrecomputationManager;
delete mPreprocessingManager;
delete mRealizationManager;
if (unsatCache) {
unsatCache->stopThread(true);
delete unsatCache;
}
if (mSatExpCache) {
mSatExpCache->stopThread(true);
delete mSatExpCache;
}
if (mReuseCompGraphCache) {
mReuseCompGraphCache->stopThread(true);
delete mReuseCompGraphCache;
}
if (mSatNodeExpCache) {
mSatNodeExpCache->stopThread(true);
delete mSatNodeExpCache;
}
if (mBlockThreadPoolThreadCount > 0) {
mBlockThreadPoolThreadsBlockingSemaphore.release(mBlockThreadPoolThreadCount);
mBlockThreadPoolThreadsReleasingSemaphore.acquire(mBlockThreadPoolThreadCount);
}
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Reasoner closed."),this);
}
void CReasonerManagerThread::logQueryProgressUpdates() {
}
bool CReasonerManagerThread::processTimer(qint64 timerID) {
if (timerID == PROGRESSQUERYTIMER) {
logQueryProgressUpdates();
return true;
}
return false;
}
const QList CReasonerManagerThread::getRequirementsForQuery(CQuery* query) {
QList ontReqList;
CSatisfiableCalculationJobsQuery* jobQuery = dynamic_cast(query);
if (jobQuery) {
QList reqList;
reqList.append(mRequirementExpander->getRequiredIndividualPrecomputationOntologyProcessingStepRequirement());
CQUERYLIST jobList(jobQuery->getJobList());
foreach (CCalculationJob* calcJob, jobList) {
CConcreteOntology* ontology = calcJob->getOntology();
QList ontSpecReqList = mRequirementExpander->getUnsatisfiedRequirementsExpanded(reqList,ontology);
foreach (COntologyProcessingRequirement* ontReq, ontSpecReqList) {
ontReqList.append(COntologyRequirementPair(ontology,ontReq));
}
CSatisfiableCalculationJob* satCalcJob = dynamic_cast(calcJob);
if (satCalcJob) {
for (CSatisfiableCalculationConstruct* satCalcConstIt = satCalcJob->getSatisfiableCalculationConstructs(); satCalcConstIt; satCalcConstIt = satCalcConstIt->getNextConstruct()) {
CSatisfiableCalculationConceptConstruct* satCalcConConstruct = dynamic_cast(satCalcConstIt);
if (satCalcConConstruct) {
for (CXSortedNegLinker* conConstIt = satCalcConConstruct->getConstructConceptLinker(); conConstIt; conConstIt = conConstIt->getNext()) {
CConcept* concept = conConstIt->getData();
bool conceptNegation = conConstIt->isNegated();
COntologyProcessingConceptSaturationRequirement* conSatReq = new COntologyProcessingConceptSaturationRequirement(concept,conceptNegation);
ontReqList.append(COntologyRequirementPair(ontology,conSatReq));
}
}
}
}
}
}
CConsistencePremisingQuery* consQuery = dynamic_cast(query);
if (consQuery) {
CConcreteOntology* ontology = consQuery->getOntology();
QList reqList;
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCONSISTENCY));
reqList = mRequirementExpander->getUnsatisfiedRequirementsExpanded(reqList,ontology);
foreach (COntologyProcessingRequirement* ontReq, reqList) {
ontReqList.append(COntologyRequirementPair(ontology,ontReq));
}
}
CTaxonomyPremisingQuery* taxQuery = dynamic_cast(query);
if (taxQuery) {
CConcreteOntology* ontology = taxQuery->getOntology();
QList reqList;
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCLASSCLASSIFY));
reqList = mRequirementExpander->getUnsatisfiedRequirementsExpanded(reqList,ontology);
foreach (COntologyProcessingRequirement* ontReq, reqList) {
ontReqList.append(COntologyRequirementPair(ontology,ontReq));
}
}
CClassificationPremisingQuery* classQuery = dynamic_cast(query);
if (classQuery) {
CConcreteOntology* ontology = classQuery->getOntology();
QList reqList;
if (classQuery->isConceptClassificationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCLASSCLASSIFY));
}
if (classQuery->isObjectRoleClassificationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSOBJECTROPERTYCLASSIFY));
}
if (classQuery->isDataRoleClassificationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSDATAROPERTYCLASSIFY));
}
reqList = mRequirementExpander->getUnsatisfiedRequirementsExpanded(reqList,ontology);
foreach (COntologyProcessingRequirement* ontReq, reqList) {
ontReqList.append(COntologyRequirementPair(ontology,ontReq));
}
}
CRealizationPremisingQuery* realQuery = dynamic_cast(query);
if (realQuery) {
CConcreteOntology* ontology = realQuery->getOntology();
QList reqList;
if (realQuery->isDynamicRealisationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCLASSCLASSIFY));
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSOBJECTROPERTYCLASSIFY));
reqList.append(realQuery->getDynamicRealizationRequirement());
} else {
if (realQuery->isSameIndividualRealisationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSSAMEINDIVIDUALSREALIZE));
}
if (realQuery->isConceptRealisationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCONCEPTREALIZE));
}
if (realQuery->isRoleRealisationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSROLEREALIZE));
}
}
reqList = mRequirementExpander->getUnsatisfiedRequirementsExpanded(reqList,ontology);
foreach (COntologyProcessingRequirement* ontReq, reqList) {
ontReqList.append(COntologyRequirementPair(ontology,ontReq));
}
}
CComplexAnsweringQuery* complexAnsweringQuery = dynamic_cast(query);
if (complexAnsweringQuery) {
CConcreteOntology* ontology = complexAnsweringQuery->getBaseOntology();
QList reqList;
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSANSWERCOMPLEXQUERY));
CComplexConceptAnsweringQuery* complexConceptAnsweringQuery = dynamic_cast(complexAnsweringQuery);
if (complexConceptAnsweringQuery) {
if (complexConceptAnsweringQuery->isSuperClassNodesComputationRequired() || complexConceptAnsweringQuery->isSubClassNodesComputationRequired() || complexConceptAnsweringQuery->isEquivalentClassNodesComputationRequired() || complexConceptAnsweringQuery->isInstancesComputationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCLASSCLASSIFY));
}
if (complexConceptAnsweringQuery->isInstancesComputationRequired()) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSOBJECTROPERTYCLASSIFY));
//reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSSAMEINDIVIDUALSREALIZE));
}
}
CComplexVariablesAnsweringQuery* compVarAnsweringQuery = dynamic_cast(complexAnsweringQuery);
if (compVarAnsweringQuery) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSOBJECTROPERTYCLASSIFY));
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCLASSCLASSIFY));
}
CComplexAxiomsDataPropertyVariablesAnsweringQuery* compDataPropVarAnsweringQuery = dynamic_cast(complexAnsweringQuery);
if (compDataPropVarAnsweringQuery) {
reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSDATAROPERTYCLASSIFY));
}
//reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSCLASSCLASSIFY));
//reqList.append(mRequirementExpander->getCompletedDefaultOntologyProcessingStepRequirement(COntologyProcessingStep::OPSOBJECTROPERTYCLASSIFY));
reqList = mRequirementExpander->getUnsatisfiedRequirementsExpanded(reqList, ontology);
foreach(COntologyProcessingRequirement* ontReq, reqList) {
ontReqList.append(COntologyRequirementPair(ontology, ontReq));
}
}
return ontReqList;
}
void CReasonerManagerThread::continueRequirementProcessing(CRequirementPreparingData* reqData, CConcreteOntology* ontology) {
COntologyRequirementPreparingData* ontReqPrepData = reqData->getOntologyRequirementPreparingData(ontology);
if (!ontReqPrepData->mCheckingReqList.isEmpty()) {
cint64 checkingTime = ontReqPrepData->mCheckingTimer.elapsed();
if (ontReqPrepData->mCheckingProcessorType == COntologyProcessingStep::OPPREPROCESSOR) {
if (!mProcessingEndMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPPREPROCESSOR))) {
mProcessingEndMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPPREPROCESSOR));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Finished preprocessing in %2 ms for ontology '%1'.").arg(ontology->getOntologyName()).arg(checkingTime),this);
}
} else if (ontReqPrepData->mCheckingProcessorType == COntologyProcessingStep::OPPRECOMPUTER) {
if (!mProcessingEndMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPPRECOMPUTER))) {
mProcessingEndMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPPRECOMPUTER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Finished precomputing in %2 ms for ontology '%1'.").arg(ontology->getOntologyName()).arg(checkingTime),this);
}
} else if (ontReqPrepData->mCheckingProcessorType == COntologyProcessingStep::OPCLASSCLASSIFIER) {
if (!mProcessingEndMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPCLASSCLASSIFIER))) {
mProcessingEndMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPCLASSCLASSIFIER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Finished class classification in %2 ms for ontology '%1'.").arg(ontology->getOntologyName()).arg(checkingTime),this);
}
} else if (ontReqPrepData->mCheckingProcessorType == COntologyProcessingStep::OPOBJECTPROPERTYCLASSIFIER) {
if (!mProcessingEndMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPOBJECTPROPERTYCLASSIFIER))) {
mProcessingEndMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPOBJECTPROPERTYCLASSIFIER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Finished object property classification in %2 ms for ontology '%1'.").arg(ontology->getOntologyName()).arg(checkingTime),this);
}
} else if (ontReqPrepData->mCheckingProcessorType == COntologyProcessingStep::OPDATAPROPERTYCLASSIFIER) {
if (!mProcessingEndMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPDATAPROPERTYCLASSIFIER))) {
mProcessingEndMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPDATAPROPERTYCLASSIFIER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Finished data property classification in %2 ms for ontology '%1'.").arg(ontology->getOntologyName()).arg(checkingTime),this);
}
} else if (ontReqPrepData->mCheckingProcessorType == COntologyProcessingStep::OPREALIZER) {
if (!mProcessingEndMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPREALIZER))) {
mProcessingEndMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPREALIZER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Finished (lazy) realization in %2 ms for ontology '%1'.").arg(ontology->getOntologyName()).arg(checkingTime),this);
}
}
for (QList::const_iterator it = ontReqPrepData->mCheckingReqList.constBegin(), itEnd = ontReqPrepData->mCheckingReqList.constEnd(); it != itEnd; ++it) {
COntologyProcessingRequirement* ontProReq(*it);
if (!ontProReq->isRequirementSatisfied(ontology)) {
ontReqPrepData->mFailedReqList.append(ontProReq);
} else {
reqData->mSatisfiedReqList.append(COntologyRequirementPair(ontology,ontProReq));
}
}
ontReqPrepData->mCheckingReqList.clear();
}
if (!ontReqPrepData->mFailedReqList.isEmpty()) {
for (QList::const_iterator it = ontReqPrepData->mFailedReqList.constBegin(), itEnd = ontReqPrepData->mFailedReqList.constEnd(); it != itEnd; ++it) {
COntologyProcessingRequirement* failedReqData(*it);
const QString& failureString = failedReqData->getRequirementFailureString(ontology);
if (!failureString.isEmpty()) {
LOG(ERROR,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("%1").arg(failureString),this);
}
reqData->mFailedReqList.append(COntologyRequirementPair(ontology,failedReqData));
}
ontReqPrepData->mFailedReqList.clear();
ontReqPrepData->mRequirementsProcessed = true;
reqData->mDepCount--;
reqData->mRequirementFailed = true;
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Requirements for ontology '%1' not satisfied.").arg(ontology->getOntologyName()),this);
}
if (!reqData->mRequirementFailed) {
if (!ontReqPrepData->mPreprocessorReqList.isEmpty()) {
if (!mProcessingStartMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPPREPROCESSOR))) {
mProcessingStartMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPPREPROCESSOR));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Preprocessing ontology '%1'.").arg(ontology->getOntologyName()),this);
}
CConfigurationBase* config = ontology->getConfiguration();
CPreprocessor* preprocessor = mPreprocessingManager->getPreprocessor(ontology,config);
CRequirementProcessedCallbackEvent* reqProcCallbackEvent = new CRequirementProcessedCallbackEvent(this,ontology,reqData, COntologyProcessingStep::OPPREPROCESSOR);
preprocessor->preprocess(ontology,config,ontReqPrepData->mPreprocessorReqList,reqProcCallbackEvent);
ontReqPrepData->mCheckingReqList = ontReqPrepData->mPreprocessorReqList;
ontReqPrepData->mPreprocessorReqList.clear();
ontReqPrepData->mCheckingProcessorType = COntologyProcessingStep::OPPREPROCESSOR;
ontReqPrepData->mCheckingTimer.start();
} else if (!ontReqPrepData->mPrecomputorReqList.isEmpty()) {
QString exprString = QString(", expressiveness '%2'").arg(ontology->getStructureSummary()->getExpressivenessString());
if (!mProcessingStartMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPPRECOMPUTER))) {
mProcessingStartMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPPRECOMPUTER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Precomputing ontology '%1'%2.").arg(ontology->getOntologyName()).arg(exprString),this);
}
CConfigurationBase* config = ontology->getConfiguration();
CPrecomputator* precomputer = mPrecomputationManager->getPrecomputator(ontology,config);
CRequirementProcessedCallbackEvent* reqProcCallbackEvent = new CRequirementProcessedCallbackEvent(this,ontology,reqData, COntologyProcessingStep::OPPRECOMPUTER);
precomputer->precompute(ontology,config,ontReqPrepData->mPrecomputorReqList,reqProcCallbackEvent);
ontReqPrepData->mCheckingReqList = ontReqPrepData->mPrecomputorReqList;
ontReqPrepData->mCheckingProcessorType = COntologyProcessingStep::OPPRECOMPUTER;
ontReqPrepData->mCheckingTimer.start();
ontReqPrepData->mPrecomputorReqList.clear();
} else if (!ontReqPrepData->mClassClassifierReqList.isEmpty()) {
QString exprString = QString(", expressiveness '%2'").arg(ontology->getStructureSummary()->getExpressivenessString());
if (!mProcessingStartMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPCLASSCLASSIFIER))) {
mProcessingStartMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPCLASSCLASSIFIER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Classifying ontology '%1'%2.").arg(ontology->getOntologyName()).arg(exprString),this);
}
CConfigurationBase* config = ontology->getConfiguration();
CSubsumptionClassifier* classClassifier = classificationMan->getClassClassifier(ontology,config);
CRequirementProcessedCallbackEvent* reqProcCallbackEvent = new CRequirementProcessedCallbackEvent(this,ontology,reqData, COntologyProcessingStep::OPCLASSCLASSIFIER);
classClassifier->classify(ontology,config,ontReqPrepData->mClassClassifierReqList,reqProcCallbackEvent);
ontReqPrepData->mCheckingReqList = ontReqPrepData->mClassClassifierReqList;
ontReqPrepData->mCheckingProcessorType = COntologyProcessingStep::OPCLASSCLASSIFIER;
ontReqPrepData->mCheckingTimer.start();
ontReqPrepData->mClassClassifierReqList.clear();
} else if (!ontReqPrepData->mObjectPropertyClassifierReqList.isEmpty()) {
QString exprString = QString(", expressiveness '%2'").arg(ontology->getStructureSummary()->getExpressivenessString());
if (!mProcessingStartMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPOBJECTPROPERTYCLASSIFIER))) {
mProcessingStartMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPOBJECTPROPERTYCLASSIFIER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Classifying object properties for ontology '%1'%2.").arg(ontology->getOntologyName()).arg(exprString),this);
}
CConfigurationBase* config = ontology->getConfiguration();
CSubsumptionClassifier* objectPropertyClassifier = classificationMan->getObjectPropertyClassifier(ontology,config);
CRequirementProcessedCallbackEvent* reqProcCallbackEvent = new CRequirementProcessedCallbackEvent(this,ontology,reqData, COntologyProcessingStep::OPOBJECTPROPERTYCLASSIFIER);
objectPropertyClassifier->classify(ontology,config,ontReqPrepData->mObjectPropertyClassifierReqList,reqProcCallbackEvent);
ontReqPrepData->mCheckingReqList = ontReqPrepData->mObjectPropertyClassifierReqList;
ontReqPrepData->mCheckingProcessorType = COntologyProcessingStep::OPOBJECTPROPERTYCLASSIFIER;
ontReqPrepData->mCheckingTimer.start();
ontReqPrepData->mObjectPropertyClassifierReqList.clear();
} else if (!ontReqPrepData->mDataPropertyClassifierReqList.isEmpty()) {
QString exprString = QString(", expressiveness '%2'").arg(ontology->getStructureSummary()->getExpressivenessString());
if (!mProcessingStartMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPDATAPROPERTYCLASSIFIER))) {
mProcessingStartMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPDATAPROPERTYCLASSIFIER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Classifying data properties for ontology '%1'%2.").arg(ontology->getOntologyName()).arg(exprString),this);
}
CConfigurationBase* config = ontology->getConfiguration();
CSubsumptionClassifier* dataPropertyClassifier = classificationMan->getDataPropertyClassifier(ontology,config);
CRequirementProcessedCallbackEvent* reqProcCallbackEvent = new CRequirementProcessedCallbackEvent(this,ontology,reqData, COntologyProcessingStep::OPDATAPROPERTYCLASSIFIER);
dataPropertyClassifier->classify(ontology,config,ontReqPrepData->mDataPropertyClassifierReqList,reqProcCallbackEvent);
ontReqPrepData->mCheckingReqList = ontReqPrepData->mDataPropertyClassifierReqList;
ontReqPrepData->mCheckingProcessorType = COntologyProcessingStep::OPDATAPROPERTYCLASSIFIER;
ontReqPrepData->mCheckingTimer.start();
ontReqPrepData->mDataPropertyClassifierReqList.clear();
} else if (!ontReqPrepData->mRealizerReqList.isEmpty()) {
QString exprString = QString(", expressiveness '%2'").arg(ontology->getStructureSummary()->getExpressivenessString());
if (!mProcessingStartMessageSet.contains(QPair(ontology,COntologyProcessingStep::OPREALIZER))) {
mProcessingStartMessageSet.insert(QPair(ontology,COntologyProcessingStep::OPREALIZER));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Realizing ontology '%1'%2.").arg(ontology->getOntologyName()).arg(exprString),this);
}
CConfigurationBase* config = ontology->getConfiguration();
CRealizer* realizer = mRealizationManager->getRealizer(ontology,config);
CRequirementProcessedCallbackEvent* reqProcCallbackEvent = new CRequirementProcessedCallbackEvent(this,ontology,reqData, COntologyProcessingStep::OPREALIZER);
realizer->realize(ontology,config,ontReqPrepData->mRealizerReqList,reqProcCallbackEvent);
ontReqPrepData->mCheckingReqList = ontReqPrepData->mRealizerReqList;
ontReqPrepData->mCheckingProcessorType = COntologyProcessingStep::OPREALIZER;
ontReqPrepData->mCheckingTimer.start();
ontReqPrepData->mRealizerReqList.clear();
} else if (!ontReqPrepData->mAnswererReqList.isEmpty()) {
QString exprString = QString(", expressiveness '%2'").arg(ontology->getStructureSummary()->getExpressivenessString());
if (!mProcessingStartMessageSet.contains(QPair(ontology, COntologyProcessingStep::OPANSWERER))) {
mProcessingStartMessageSet.insert(QPair(ontology, COntologyProcessingStep::OPANSWERER));
LOG(INFO, "::Konclude::Reasoner::Kernel::ReasonerManager", logTr("Initializing complex query answering for ontology '%1'%2.").arg(ontology->getOntologyName()).arg(exprString), this);
}
CConfigurationBase* config = ontology->getConfiguration();
bool created = false;
if (!mAnswererManager) {
mAnswererManager = new CAnsweringManagerThread(this, config);
created = true;
}
CRequirementProcessedCallbackEvent* reqProcCallbackEvent = new CRequirementProcessedCallbackEvent(this, ontology, reqData, COntologyProcessingStep::OPANSWERER);
ontology->getProcessingSteps()->getOntologyProcessingStepDataVector()->getProcessingStepData(COntologyProcessingStep::OPSANSWERCOMPLEXQUERY)->getProcessingStatus()->setProcessingFlags(COntologyProcessingStatus::PSCOMPLETELYYPROCESSED);
ontology->getProcessingSteps()->getOntologyProcessingStepDataVector()->getProcessingStepData(COntologyProcessingStep::OPSANSWERCOMPLEXQUERY)->getProcessingStatus()->setErrorFlags(COntologyProcessingStatus::PSSUCESSFULL);
ontReqPrepData->mCheckingReqList = ontReqPrepData->mAnswererReqList;
ontReqPrepData->mCheckingProcessorType = COntologyProcessingStep::OPANSWERER;
ontReqPrepData->mCheckingTimer.start();
ontReqPrepData->mAnswererReqList.clear();
if (created) {
mAnswererManager->prepareAnswering(ontology, reqProcCallbackEvent);
} else if (!mAnswererPrepared) {
mAnswererPreparedCallbackQueue.append(reqProcCallbackEvent);
} else {
reqProcCallbackEvent->doCallback();
}
} else {
reqData->mDepCount--;
}
}
if (reqData->mDepCount <= 0) {
if (reqData->mQuery) {
initiateQueryReasoning(reqData->mQuery,reqData->mCallback,reqData->mReasoningData,reqData->mFailedReqList);
} else {
CCallbackData* callback = reqData->mCallback;
if (callback) {
callback->doCallback();
}
delete reqData;
}
}
}
void CReasonerManagerThread::prepareOntologyReasoning(CPrepareOntologyEvent* poe) {
CConcreteOntology* ontology = poe->getOntology();
CCallbackData* callbackData = poe->getCallbackData();
if (ontology) {
QList reqList(*poe->getOntologyProcessingRequirementList());
reqList = mRequirementExpander->getUnsatisfiedRequirementsExpanded(reqList,ontology);
if (!reqList.isEmpty()) {
// satisfy query requirements first
CRequirementPreparingData* reqPrepData = new CRequirementPreparingData(callbackData,nullptr,nullptr);
for (QList::const_iterator it = reqList.constBegin(), itEnd = reqList.constEnd(); it != itEnd; ++it) {
COntologyProcessingRequirement* requirement = *it;
COntologyRequirementPreparingData* ontReqPrepData = reqPrepData->getOntologyRequirementPreparingData(ontology);
ontReqPrepData->addOntologyRequirement(requirement);
}
reqPrepData->mDepCount = reqPrepData->mOntoReqDataHash.count();
mProcessingRequirementsSet.insert(reqPrepData);
continueRequirementProcessing(reqPrepData,ontology);
} else {
if (callbackData) {
callbackData->doCallback();
}
}
} else {
LOG(ERROR,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Ontology not specified for processing requirements."),this);
if (callbackData) {
callbackData->doCallback();
}
}
}
void CReasonerManagerThread::prepareQueryReasoning(CCalcQueryEvent *cqe) {
CQuery* query = cqe->getQuery();
CCallbackData* callbackData = cqe->getCallbackData();
CReasoningTaskData* reasoningData = new CReasoningTaskData();
QList reqList(getRequirementsForQuery(query));
if (reqList.isEmpty()) {
initiateQueryReasoning(query,callbackData,reasoningData,QList());
} else {
// satisfy query requirements first
CRequirementPreparingData* reqPrepData = new CRequirementPreparingData(callbackData,query,reasoningData);
reasoningData->mReqPrepData = reqPrepData;
for (QList::const_iterator it = reqList.constBegin(), itEnd = reqList.constEnd(); it != itEnd; ++it) {
COntologyRequirementPair ontReqPair(*it);
CConcreteOntology* ontology = ontReqPair.mOntology;
COntologyProcessingRequirement* requirement = ontReqPair.mRequirement;
COntologyRequirementPreparingData* ontReqPrepData = reqPrepData->getOntologyRequirementPreparingData(ontology);
ontReqPrepData->addOntologyRequirement(requirement);
}
reqPrepData->mDepCount = reqPrepData->mOntoReqDataHash.count();
mProcessingRequirementsSet.insert(reqPrepData);
if (reqPrepData->mDepCount <= 0) {
initiateQueryReasoning(query,callbackData,reasoningData,reqPrepData->mFailedReqList);
} else {
for (QHash::const_iterator it = reqPrepData->mOntoReqDataHash.constBegin(), itEnd = reqPrepData->mOntoReqDataHash.constEnd(); it != itEnd; ++it) {
CConcreteOntology* ontology = it.key();
COntologyRequirementPreparingData* ontReqRepData = it.value();
continueRequirementProcessing(reqPrepData,ontology);
}
}
}
}
void CReasonerManagerThread::initiateQueryReasoning(CQuery* query, CCallbackData* callbackData, CReasoningTaskData* reasoningData, const QList& failedRequirementList) {
reasoningData->mStartTime.start();
updateBeginingCalculationStatistics(reasoningData);
if (!failedRequirementList.isEmpty()) {
CConcreteOntology* ontology = nullptr;
for (QList::const_iterator it = failedRequirementList.constBegin(), itEnd = failedRequirementList.constEnd(); it != itEnd; ++it) {
ontology = it->mOntology;
COntologyProcessingRequirement* requirement(it->mRequirement);
query->addErrorString(QString("Processing requirements for Ontology '%1' for Query '%2' failed.").arg(ontology->getOntologyName()).arg(query->getQueryName()));
if (ontology) {
CConsistence* cons = ontology->getConsistence();
if (cons) {
if (!cons->isOntologyConsistent()) {
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Ontology '%1' for Query '%2' is inconsistent.").arg(ontology->getOntologyName()).arg(query->getQueryName()),this);
query->addQueryError(new CQueryInconsitentOntologyError(ontology));
}
}
}
}
if (ontology) {
updateFinishingCalculationStatistics(reasoningData,query->getQueryStatistics(),ontology->getConfiguration());
} else {
updateFinishingCalculationStatistics(reasoningData,query->getQueryStatistics());
}
CCallbackData* callback = callbackData;
if (callback) {
callback->doCallback();
}
delete reasoningData;
} else {
CSatisfiableCalculationJobsQuery* jobQuery = dynamic_cast(query);
if (jobQuery) {
CQUERYLIST jobList(jobQuery->getJobList());
bool jobCalculated = false;
cint64 depCount = 0;
CConcreteOntology* ontology = nullptr;
FOREACHIT (CCalculationJob* calcJob, jobList) {
CSatisfiableCalculationJob* satCalcJob = dynamic_cast(calcJob);
if (satCalcJob) {
depCount++;
CJobSatisfiableCallbackContextData* satCallbackData = new CJobSatisfiableCallbackContextData(satCalcJob);
CQueryJobCalculatedSatisfiableCallbackEvent* callback = new CQueryJobCalculatedSatisfiableCallbackEvent(this,jobQuery,satCallbackData);
mCalculationManager->calculateJob(satCalcJob,callback);
mCalcJobSet.insert(satCalcJob);
jobCalculated = true;
ontology = satCalcJob->getOntology();
}
}
reasoningData->mCallback = callbackData;
reasoningData->mDepCount = depCount;
mReasoningTaskDataHash.insert((cint64)query,reasoningData);
mCalculatingQuerySet.insert(query);
reasoningData->mFinQueryCallback = new CCalcedQueryEvent(this,jobQuery);
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Processing Query '%1'.").arg(query->getQueryName()),this);
}
CIsTriviallyConsistentQuery* trivConsQuery = dynamic_cast(query);
if (trivConsQuery) {
reasoningData->mCallback = callbackData;
CConcreteOntology* ontology = trivConsQuery->getOntology();
trivConsQuery->constructResult(ontology->getBuildData());
qint64 mSecs = reasoningData->mStartTime.elapsed();
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Query '%1' processed in '%2' ms.").arg(trivConsQuery->getQueryName()).arg(mSecs),this);
CCallbackData* callback = reasoningData->mCallback;
if (callback) {
callback->doCallback();
}
delete reasoningData;
}
CConsistencePremisingQuery* consQuery = dynamic_cast(query);
if (consQuery) {
reasoningData->mCallback = callbackData;
CQueryStatistics* queryStats = consQuery->getQueryStatistics();
CConcreteOntology* ontology = consQuery->getOntology();
if (queryStats) {
CConsistenceStatistics* consStats = ontology->getConsistence()->getConsistenceStatistics();
if (consStats) {
foreach(QString statName, consStats->getStatisticsNameStringList()) {
cint64 statValue = consStats->getStatisticIntegerValue(statName);
queryStats->addProcessingStatistics(statName, statValue);
}
}
}
updateFinishingCalculationStatistics(reasoningData,queryStats,ontology->getConfiguration());
consQuery->constructResult(ontology->getConsistence());
qint64 mSecs = reasoningData->mStartTime.elapsed();
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Query '%1' processed in '%2' ms.").arg(consQuery->getQueryName()).arg(mSecs),this);
CCallbackData* callback = reasoningData->mCallback;
if (callback) {
callback->doCallback();
}
delete reasoningData;
}
CTaxonomyPremisingQuery *taxQuery = dynamic_cast(query);
if (taxQuery) {
reasoningData->mCallback = callbackData;
CQueryStatistics* queryStats = taxQuery->getQueryStatistics();
CConcreteOntology* ontology = taxQuery->getOntology();
if (queryStats) {
CClassConceptClassification* classConClassif = ontology->getClassification()->getClassConceptClassification();
if (classConClassif) {
CClassificationStatistics* classifStats = classConClassif->getClassificationStatistics();
if (classifStats) {
foreach(QString statName, classifStats->getStatisticsNameStringList()) {
cint64 statValue = classifStats->getStatisticIntegerValue(statName);
queryStats->addProcessingStatistics(statName, statValue);
}
}
}
}
updateFinishingCalculationStatistics(reasoningData,queryStats,ontology->getConfiguration());
taxQuery->constructResult(ontology->getClassification()->getClassConceptClassification()->getClassConceptTaxonomy());
qint64 mSecs = reasoningData->mStartTime.elapsed();
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Query '%1' processed in '%2' ms.").arg(taxQuery->getQueryName()).arg(mSecs),this);
CCallbackData* callback = reasoningData->mCallback;
if (callback) {
callback->doCallback();
}
delete reasoningData;
}
CClassificationPremisingQuery* classQuery = dynamic_cast(query);
if (classQuery) {
reasoningData->mCallback = callbackData;
CQueryStatistics* queryStats = classQuery->getQueryStatistics();
CConcreteOntology* ontology = classQuery->getOntology();
updateFinishingCalculationStatistics(reasoningData,queryStats,ontology->getConfiguration());
classQuery->constructResult(ontology->getClassification());
qint64 mSecs = reasoningData->mStartTime.elapsed();
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Query '%1' processed in '%2' ms.").arg(classQuery->getQueryName()).arg(mSecs),this);
CCallbackData* callback = reasoningData->mCallback;
if (callback) {
callback->doCallback();
}
delete reasoningData;
}
CRealizationPremisingQuery* realQuery = dynamic_cast(query);
if (realQuery) {
reasoningData->mCallback = callbackData;
CQueryStatistics* queryStats = realQuery->getQueryStatistics();
CConcreteOntology* ontology = realQuery->getOntology();
updateFinishingCalculationStatistics(reasoningData,queryStats,ontology->getConfiguration());
realQuery->constructResult(ontology->getRealization());
qint64 mSecs = reasoningData->mStartTime.elapsed();
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Query '%1' processed in '%2' ms.").arg(realQuery->getQueryName()).arg(mSecs),this);
CCallbackData* callback = reasoningData->mCallback;
if (callback) {
callback->doCallback();
}
delete reasoningData;
}
CComplexAnsweringQuery* compAnsQuery = dynamic_cast(query);
if (compAnsQuery) {
reasoningData->mCallback = callbackData;
CConcreteOntology* ontology = compAnsQuery->getBaseOntology();
CCallbackData* callback = reasoningData->mCallback;
bool confCollectProcessStatistics = CConfigDataReader::readConfigBoolean(ontology->getConfiguration(), "Konclude.Calculation.Answering.CollectProcessStatistics", false);
if (confCollectProcessStatistics) {
reasoningData->mFinQueryCallback = new CCalcedQueryEvent(this, compAnsQuery);
mReasoningTaskDataHash.insert((cint64)query, reasoningData);
callback = reasoningData->mFinQueryCallback;
}
mAnswererManager->answerComplexQuery(compAnsQuery, callback);
if (!confCollectProcessStatistics) {
delete reasoningData;
}
}
}
}
void CReasonerManagerThread::prepareSatisfiableBoxReasoning(CReasoningSatisfiableCalculationJobEvent *cbse) {
CSatisfiableCalculationJob* calcJob = cbse->getSatisfiableCalculationJob();
CCallbackData* callbackData = cbse->getCallbackData();
CJobSatisfiableCallbackContextData* satCallbackData = (CJobSatisfiableCallbackContextData*)callbackData->getCallbackDataContext();
if (!satCallbackData) {
satCallbackData = new CJobSatisfiableCallbackContextData(calcJob);
}
CJobCalculatedSatisfiableCallbackEvent* callback = new CJobCalculatedSatisfiableCallbackEvent(this,satCallbackData);
mCalculationManager->calculateJob(calcJob,callback);
mCalcJobSet.insert(calcJob);
CReasoningTaskData* reasoningData = new CReasoningTaskData();
reasoningData->mCallback = callbackData;
mReasoningTaskDataHash.insert((cint64)calcJob,reasoningData);
}
bool CReasonerManagerThread::updateBeginingCalculationStatistics(CReasoningTaskData* reaTaskData, CConfiguration* config) {
if (!config) {
config = configProvider->getCurrentConfiguration();
}
if (CConfigDataReader::readConfigBoolean(config,"Konclude.Query.Statistics.CollectCalculationStatistics",false)) {
QHash* mBeginStatHash = mCalculationManager->getCalculationStatistics();
reaTaskData->mCalcStat = mBeginStatHash;
return true;
}
return false;
}
bool CReasonerManagerThread::updateFinishingCalculationStatistics(CReasoningTaskData* reaTaskData, CQueryStatistics* queryStat, CConfiguration* config) {
if (queryStat) {
if (!config) {
config = configProvider->getCurrentConfiguration();
}
if (CConfigDataReader::readConfigBoolean(config,"Konclude.Query.Statistics.CollectCalculationStatistics",false)) {
QHash* mBeginStatHash = reaTaskData->mCalcStat;
if (mBeginStatHash) {
QHash* mFinishStatHash = mCalculationManager->getCalculationStatistics();
for (QHash::const_iterator itF = mFinishStatHash->constBegin(), itFEnd = mFinishStatHash->constEnd(); itF != itFEnd; ++itF) {
QString statName = itF.key();
cint64 finVal = itF.value();
cint64 begVal = 0;//mBeginStatHash->value(statName);
queryStat->addProcessingStatistics(statName,finVal-begVal);
}
delete mFinishStatHash;
}
queryStat->addProcessingStatistics("calculation-reasoning-time",reaTaskData->mStartTime.elapsed());
}
if (CConfigDataReader::readConfigBoolean(config,"Konclude.Query.Statistics.CollectProcessingStepsStatistics",false) && reaTaskData->mReqPrepData) {
QSet addedStatSet;
for (QList::const_iterator it = reaTaskData->mReqPrepData->mSatisfiedReqList.constBegin(), itEnd = reaTaskData->mReqPrepData->mSatisfiedReqList.constEnd(); it != itEnd; ++it) {
COntologyRequirementPair ontReqPair(*it);
CConcreteOntology* ontology = ontReqPair.mOntology;
COntologyProcessingRequirement* requirement = ontReqPair.mRequirement;
COntologyProcessingStepRequirement* ontProcStepRequirement = dynamic_cast(requirement);
if (ontProcStepRequirement) {
COntologyProcessingStepData* procStepData = ontology->getProcessingSteps()->getOntologyProcessingStepDataVector()->getProcessingStepData(ontProcStepRequirement->getRequiredProcessingStep()->getOntologyProcessingType());
if (procStepData) {
COntologyProcessingStatistics* procStepStatistics = procStepData->getProcessingStatistics(false);
if (procStepStatistics && !addedStatSet.contains(procStepStatistics)) {
addedStatSet.insert(procStepStatistics);
queryStat->addProcessingStatistics(procStepStatistics);
}
}
}
}
}
return true;
}
return false;
}
void CReasonerManagerThread::finishSatisfiableBoxReasoning(CJobCalculatedSatisfiableCallbackEvent *cbsce) {
CJobSatisfiableCallbackContextData *contextData = (CJobSatisfiableCallbackContextData *)cbsce->getCallbackDataContext();
CSatisfiableCalculationJob* satCalcJob = contextData->getSatisfiableCalculationJob();
bool satisfiable = contextData->isSatisfiable();
bool calcError = contextData->hasCalculationError();
if (calcError) {
LOG(ERROR,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Error while calculating job."),this);
QString errorString = mCalculationManager->getCalculationErrorString(contextData->getCalculationErrorCode());
if (!errorString.isEmpty()) {
LOG(ERROR,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Calculation Error: '%1'.").arg(errorString),this);
}
}
CReasoningTaskData* reasoningData = mReasoningTaskDataHash.value((cint64)satCalcJob,nullptr);
reasoningData->mDepCount--;
CCallbackData* callback = reasoningData->mCallback;
if (callback) {
callback->setCallbackDataContext(cbsce->takeCallbackDataContext());
callback->doCallback();
}
mReasoningTaskDataHash.remove((cint64)satCalcJob);
delete reasoningData;
mCalcJobSet.remove(satCalcJob);
}
QString CReasonerManagerThread::getLoggingCalculationStatisticsMemorySizeString(cint64 memSize) {
QString memString;
if (memSize > 10*1024*1024) {
memString = QString("%1 MByte").arg(memSize/(1024*1024));
} else if (memSize > 10*1024) {
memString = QString("%1 KByte").arg(memSize/(1024));
} else {
memString = QString("%1 Byte").arg(memSize);
}
return memString;
}
QString CReasonerManagerThread::getLoggingCalculationStatisticsTimeSizeString(double milliseconds) {
QString compTimeString;
if (milliseconds > 2*1000*60*60*24*356) {
compTimeString = QString("%1 y").arg(milliseconds/(1000*60*60*24*356));
} else if (milliseconds > 2*1000*60*60*24) {
compTimeString = QString("%1 d").arg(milliseconds/(1000*60*60*24));
} else if (milliseconds > 10*1000*60*60) {
compTimeString = QString("%1 h").arg(milliseconds/(1000*60*60));
} else if (milliseconds > 10*1000*60) {
compTimeString = QString("%1 m").arg(milliseconds/(1000*60));
} else if (milliseconds > 10*1000) {
compTimeString = QString("%1 s").arg(milliseconds/(1000));
} else {
compTimeString = QString("%1 ms").arg(milliseconds);
}
return compTimeString;
}
void CReasonerManagerThread::loggingCalculationStatistics() {
QHash* mCalcStatHash = mCalculationManager->getCalculationStatistics();
if (mCalcStatHash) {
QString compTime = getLoggingCalculationStatisticsTimeSizeString(mCalcStatHash->value("calculation-computing-time"));
QString memCons = getLoggingCalculationStatisticsMemorySizeString(mCalcStatHash->value("calculation-memory-consumption"));
QString memRes = getLoggingCalculationStatisticsMemorySizeString(mCalcStatHash->value("calculation-memory-reservation"));
QString statString = QString("Up to now calculation computing time: %1, calculation memory consumption: %2.")
.arg(compTime)
.arg(memCons);
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString,this);
delete mCalcStatHash;
}
}
void CReasonerManagerThread::finishQuerySatisfiableBoxReasoning(CQueryJobCalculatedSatisfiableCallbackEvent *cbsce) {
CJobSatisfiableCallbackContextData *contextData = (CJobSatisfiableCallbackContextData *)cbsce->getCallbackDataContext();
CSatisfiableCalculationJobsQuery* jobQuery = cbsce->getSatisfiableCalclulationJobsQuery();
CSatisfiableCalculationJob* satCalcJob = contextData->getSatisfiableCalculationJob();
bool satisfiable = contextData->isSatisfiable();
bool calcError = contextData->hasCalculationError();
if (calcError) {
LOG(ERROR,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Error while calculating job for query '%1'.").arg(jobQuery->getQueryName()),this);
QString errorString = mCalculationManager->getCalculationErrorString(contextData->getCalculationErrorCode());
if (!errorString.isEmpty()) {
LOG(ERROR,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Calculation Error: '%1'.").arg(errorString),this);
jobQuery->addErrorString("Calculation error: "+errorString);
}
}
CReasoningTaskData* reasoningQueryData = mReasoningTaskDataHash.value((cint64)jobQuery,nullptr);
updateFinishingCalculationStatistics(reasoningQueryData,jobQuery->getQueryStatistics());
QString newAnswerString;
bool queryFinished = false;
if (!reasoningQueryData->mAnswered) {
queryFinished = jobQuery->interpreteJobSatisfiableCalculation(satCalcJob,satisfiable,calcError,&newAnswerString);
}
CReasoningTaskData* reasoningJobData = mReasoningTaskDataHash.value((cint64)satCalcJob,nullptr);
if (reasoningJobData) {
reasoningJobData->mDepCount--;
CCallbackData* callback = reasoningJobData->mCallback;
if (callback) {
callback->setCallbackDataContext(cbsce->takeCallbackDataContext());
callback->doCallback();
}
mReasoningTaskDataHash.remove((cint64)satCalcJob);
delete reasoningJobData;
}
mCalcJobSet.remove(satCalcJob);
if (--(reasoningQueryData->mDepCount) <= 0) {
reasoningQueryData->mAnswered |= queryFinished;
reasoningQueryData->mFinQueryCallback->sendEventWithAnswer(newAnswerString);
}
}
void CReasonerManagerThread::finishQueryReasoning(CCalcedQueryEvent *cqe) {
CQuery *query = cqe->getQuery();
CReasoningTaskData* reasoningData = mReasoningTaskDataHash.value((cint64)query,nullptr);
CComplexAnsweringQuery* compAnsQuery = dynamic_cast(query);
if (compAnsQuery) {
CQueryStatistics* queryStats = query->getQueryStatistics();
if (queryStats) {
CAnsweringStatistics* stats = mAnswererManager->getAnsweringStatistics(compAnsQuery->getBaseOntology());
if (stats) {
for (const QString& statName : stats->getStatisticsNameStringList()) {
cint64 statValue = stats->getStatisticIntegerValue(statName);
queryStats->addProcessingStatistics(statName, statValue);
}
delete stats;
}
updateFinishingCalculationStatistics(reasoningData, queryStats, compAnsQuery->getBaseOntology()->getConfiguration());
}
} else {
LOG(INFO, "::Konclude::Reasoner::Kernel::ReasonerManager", logTr("Query '%1' processed. Question '%2' answered with '%3'.\r\n").arg(cqe->getQueryName()).arg(cqe->getQueryString()).arg(cqe->getAnswerString()), this);
qint64 mSecs = reasoningData->mStartTime.elapsed();
LOG(INFO, "::Konclude::Reasoner::Kernel::ReasonerManager", logTr("Query '%1' processed in '%2' ms.").arg(cqe->getQueryName()).arg(mSecs), this);
}
// print calculation statistics
loggingCalculationStatistics();
CCallbackData* callback = reasoningData->mCallback;
if (callback) {
callback->doCallback();
}
mCalculatingQuerySet.remove(query);
mReasoningTaskDataHash.remove((cint64)query);
delete reasoningData;
}
bool CReasonerManagerThread::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (CIntervalThread::processCustomsEvents(type,event)) {
return true;
} else if (type == CReasoningSatisfiableCalculationJobEvent::EVENTTYPE) {
CReasoningSatisfiableCalculationJobEvent *cbse = static_cast(event);
prepareSatisfiableBoxReasoning(cbse);
return true;
} else if (type == CJobCalculatedSatisfiableCallbackEvent::EVENTTYPE) {
CJobCalculatedSatisfiableCallbackEvent *cbsce = static_cast(event);
finishSatisfiableBoxReasoning(cbsce);
return true;
} else if (type == CQueryJobCalculatedSatisfiableCallbackEvent::EVENTTYPE) {
CQueryJobCalculatedSatisfiableCallbackEvent *cbsce = static_cast(event);
finishQuerySatisfiableBoxReasoning(cbsce);
return true;
} else if (type == CCalcQueryEvent::EVENTTYPE) {
CCalcQueryEvent *cqe = static_cast(event);
prepareQueryReasoning(cqe);
return true;
} else if (type == CPrepareOntologyEvent::EVENTTYPE) {
CPrepareOntologyEvent* poe = static_cast(event);
prepareOntologyReasoning(poe);
return true;
} else if (type == CCalcedQueryEvent::EVENTTYPE) {
CCalcedQueryEvent *cqe = static_cast(event);
finishQueryReasoning(cqe);
return true;
} else if (type == CRequirementProcessedCallbackEvent::EVENTTYPE) {
CRequirementProcessedCallbackEvent* rpce = static_cast(event);
CConcreteOntology* ontology = rpce->getOntology();
CRequirementPreparingData* reqPrepData = rpce->getRequirementPreparingData();
continueRequirementProcessing(reqPrepData, ontology);
if (rpce->mProcType == COntologyProcessingStep::OPANSWERER && !mAnswererPrepared) {
mAnswererPrepared = true;
for (CRequirementProcessedCallbackEvent* prepReqData : mAnswererPreparedCallbackQueue) {
prepReqData->doCallback();
}
mAnswererPreparedCallbackQueue.clear();
}
return true;
}
return false;
}
}; // end namespace Manager
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude