/*
* 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 "CPrecomputationThread.h"
namespace Konclude {
namespace Reasoner {
namespace Consistiser {
CPrecomputationThread::CPrecomputationThread(CReasonerManager *reasonerManager) : CThread("Precomputation-Thread") {
mReasoner = reasonerManager;
mCalculationManager = 0;
mCurrRunningTestParallelCount = 0;
mConfMaxTestParallelCount = 1;
mStatCalculatingJobs = 0;
mConfMaxTestBatchCreationCount = -1;
startThread(QThread::HighPriority);
}
CPrecomputationThread::~CPrecomputationThread() {
stopThread();
}
bool CPrecomputationThread::precompute(CConcreteOntology* ontology, CConfigurationBase* config, const QList& requirementList, CCallbackData* callback) {
postEvent(new CPrecomputeOntologyEvent(ontology,config,requirementList,callback));
return true;
}
bool CPrecomputationThread::precompute(CConcreteOntology* ontology, CConfigurationBase* config, const QList& requirementList) {
CBlockingCallbackData callback;
postEvent(new CPrecomputeOntologyEvent(ontology,config,requirementList,&callback));
callback.waitForCallback();
return true;
}
bool CPrecomputationThread::callbackPrecomputed(CConcreteOntology* ontology, CCallbackData* callback) {
bool callbackPecomputedOnto = false;
CPrecomputation* precomputation = ontology->getPrecomputation();
if (precomputation && precomputation->isPrecomputed()) {
callbackPecomputedOnto = true;
if (callback) {
callback->doCallback();
}
} else {
CBlockingCallbackData callbackBlock;
postEvent(new CCallbackPrecomputedOntologyEvent(ontology,&callbackBlock,callback));
callbackBlock.waitForCallback();
CCallbackDataContext* callbackContext = callbackBlock.getCallbackDataContext();
if (callbackContext) {
CPrecomputationCallbackDataContext* possCallbackContext = dynamic_cast(callbackContext);
callbackPecomputedOnto = possCallbackContext->isPrecomputing();
}
}
return callbackPecomputedOnto;
}
bool CPrecomputationThread::canProcessMoreTests() {
return mCurrRunningTestParallelCount < mConfMaxTestParallelCount;
}
bool CPrecomputationThread::doNextPendingTests() {
bool createdNewTests = false;
bool nextTestCreated = true;
cint64 jobCreationCount = 0;
while (canProcessMoreTests() && nextTestCreated) {
nextTestCreated = false;
bool workCreated = createNextTest();
if (workCreated) {
++jobCreationCount;
nextTestCreated = true;
if (mConfMaxTestBatchCreationCount == -1 || jobCreationCount <= mConfMaxTestBatchCreationCount) {
createdNewTests = true;
} else {
createdNewTests = false;
postEvent(new CRescheduleJobCreationEvent());
}
} else {
nextTestCreated = false;
}
}
return createdNewTests;
}
CPrecomputationThread* CPrecomputationThread::processCalculationJob(CSatisfiableCalculationJob* job, COntologyPrecomputationItem* preCompItem, CPrecomputationTestingItem* preTestItem) {
CConsistenceCalculationStatisticsCollection* statColl = nullptr;
if (preCompItem->isProcessStatisticsCollectionConfigured()) {
statColl = preCompItem->getCalculationStatisticsCollection();
preTestItem->setStatisticCollection(statColl);
}
job->setCalclulationStatisticsCollector(statColl);
CPrecomputationCalculatedCallbackEvent* callbackEvent = new CPrecomputationCalculatedCallbackEvent(this,job,preTestItem);
preCompItem->getPrecomputationTestingItemSet()->insert(preTestItem);
mCurrRunningTestParallelCount++;
++mStatCalculatingJobs;
if (!mCalculationManager) {
mCalculationManager = mReasoner->getCalculationManager();
}
if (mCalculationManager) {
mCalculationManager->calculateJob(job,callbackEvent);
} else {
mReasoner->reasoningSatisfiableCalcualtionJob(job,callbackEvent);
}
return this;
}
CPrecomputationThread* CPrecomputationThread::processCalculationJob(CApproximatedSaturationCalculationJob* job, COntologyPrecomputationItem* preCompItem, CPrecomputationTestingItem* preTestItem) {
CConsistenceCalculationStatisticsCollection* statColl = nullptr;
if (preCompItem->isProcessStatisticsCollectionConfigured()) {
statColl = preCompItem->getCalculationStatisticsCollection();
preTestItem->setStatisticCollection(statColl);
}
job->setCalclulationStatisticsCollector(statColl);
CSaturationPrecomputationCalculatedCallbackEvent* callbackEvent = new CSaturationPrecomputationCalculatedCallbackEvent(this,job,preTestItem);
preCompItem->getPrecomputationTestingItemSet()->insert(preTestItem);
mCurrRunningTestParallelCount++;
++mStatCalculatingJobs;
if (!mCalculationManager) {
mCalculationManager = mReasoner->getCalculationManager();
}
if (mCalculationManager) {
mCalculationManager->calculateJob(job,callbackEvent);
}
return this;
}
COntologyPrecomputationItem* CPrecomputationThread::initializeOntologyPrecomputionItem(CConcreteOntology* ontology, CConfigurationBase* config) {
COntologyPrecomputationItem* item = new COntologyPrecomputationItem();
item->initPrecomputationItem(ontology,config);
return item;
}
bool CPrecomputationThread::addOntologyPrecomputionCallback(COntologyPrecomputationItem* item, CCallbackData* callback) {
item->addPrecomputationFinishedCallback(callback);
return this;
}
bool CPrecomputationThread::addOntologyPrecomputionRequirements(COntologyPrecomputationItem* item, COntologyProcessingRequirement* requirement) {
item->addPrecomputationRequirement(requirement);
return true;
}
bool CPrecomputationThread::processCustomsEvents(QEvent::Type type, CCustomEvent* event) {
if (CThread::processCustomsEvents(type,event)) {
return true;
} else if (type == CPrecomputeOntologyEvent::EVENTTYPE) {
CPrecomputeOntologyEvent* poe = (CPrecomputeOntologyEvent*)event;
CCallbackData* callbackData = poe->getCallbackData();
CConfigurationBase* configBase = poe->getConfiguration();
CConcreteOntology* ontology = poe->getOntology();
QList* requirementList = poe->getProcessingRequirementList();
COntologyPrecomputationItem* item = mOntItemHash.value(ontology);
if (!item) {
item = initializeOntologyPrecomputionItem(ontology,configBase);
mOntItemHash.insert(ontology,item);
mActiveOntItemSet.insert(item);
mProcessingOntItemList.append(item);
} else {
if (!mActiveOntItemSet.contains(item)) {
mInactiveOntItemSet.remove(item);
mActiveOntItemSet.insert(item);
mProcessingOntItemList.append(item);
}
}
for (QList::const_iterator it = requirementList->constBegin(), itEnd = requirementList->constEnd(); it != itEnd; ++it) {
COntologyProcessingRequirement* requ(*it);
addOntologyPrecomputionRequirements(item,requ);
}
if (callbackData) {
addOntologyPrecomputionCallback(item,callbackData);
}
doNextPendingTests();
return true;
} else if (type == CCallbackPrecomputedOntologyEvent::EVENTTYPE) {
CCallbackPrecomputedOntologyEvent* cpoe = (CCallbackPrecomputedOntologyEvent*)event;
CConcreteOntology* ontology = cpoe->getOntology();
CCallbackData* precomputedCallbackData = cpoe->getPrecomputedCallbackData();
CCallbackData* installedCallbackData = cpoe->getCallbackPossibleCallbackData();
COntologyPrecomputationItem* item = mOntItemHash.value(ontology);
if (item) {
addOntologyPrecomputionCallback(item,precomputedCallbackData);
if (installedCallbackData) {
CPrecomputationCallbackDataContext* callbackDataContext = new CPrecomputationCallbackDataContext(true,ontology);
installedCallbackData->setCallbackDataContext(callbackDataContext);
installedCallbackData->doCallback();
}
} else {
if (installedCallbackData) {
CPrecomputationCallbackDataContext* callbackDataContext = new CPrecomputationCallbackDataContext(false,ontology);
installedCallbackData->setCallbackDataContext(callbackDataContext);
installedCallbackData->doCallback();
}
}
return true;
} else if (type == CRetrievedPrecomputationIndividualsCallbackEvent::EVENTTYPE) {
CRetrievedPrecomputationIndividualsCallbackEvent* cpoe = (CRetrievedPrecomputationIndividualsCallbackEvent*)event;
precomputationIndividualsRetrieved(cpoe->getOntologyPrecomputationItem(), cpoe);
return true;
} else if (type == CPrecomputationCalculatedCallbackEvent::EVENTTYPE) {
CPrecomputationCalculatedCallbackEvent* pcce = (CPrecomputationCalculatedCallbackEvent*)event;
--mCurrRunningTestParallelCount;
CPrecomputationTestingItem* testingItem = pcce->getTestingItem();
COntologyPrecomputationItem* ontPreCompItem = testingItem->getOntologyPrecomputationItem();
ontPreCompItem->getPrecomputationTestingItemSet()->remove(testingItem);
CConsistenceCalculationStatisticsCollection* statisticCollection = testingItem->getUsedStatisticsCollection();
precomputationTested(ontPreCompItem, testingItem, pcce);
if (statisticCollection) {
ontPreCompItem->reuseCalculationStatisticsCollection(statisticCollection);
}
doNextPendingTests();
return true;
} else if (type == CSaturationPrecomputationCalculatedCallbackEvent::EVENTTYPE) {
CSaturationPrecomputationCalculatedCallbackEvent* spcce = (CSaturationPrecomputationCalculatedCallbackEvent*)event;
--mCurrRunningTestParallelCount;
CPrecomputationTestingItem* testingItem = spcce->getPrecomputationTestingItem();
COntologyPrecomputationItem* ontPreCompItem = testingItem->getOntologyPrecomputationItem();
ontPreCompItem->getPrecomputationTestingItemSet()->remove(testingItem);
CConsistenceCalculationStatisticsCollection* statisticCollection = testingItem->getUsedStatisticsCollection();
precomputationTested(ontPreCompItem,testingItem,spcce);
if (statisticCollection) {
ontPreCompItem->reuseCalculationStatisticsCollection(statisticCollection);
}
doNextPendingTests();
return true;
} else if (type == CRescheduleJobCreationEvent::EVENTTYPE) {
doNextPendingTests();
return true;
}
return false;
}
}; // end namespace Consistiser
}; // end namespace Reasoner
}; // end namespace Konclude