/*
* 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 "CSubsumptionClassifierThread.h"
namespace Konclude {
namespace Reasoner {
namespace Classifier {
CSubsumptionClassifierThread::CSubsumptionClassifierThread(CReasonerManager *reasonerManager) : CThread("Classifier-Thread") {
reasoner = reasonerManager;
calculationManager = 0;
currRunningTestParallelCount = 0;
confMaxTestParallelCount = 1;
confMinTestParallelCount = 15;
mStatCalculatingJobs = 0;
mClassifierActive = false;
statistics = new CClassifierStatistics();
startThread(QThread::HighPriority);
}
CSubsumptionClassifierThread::~CSubsumptionClassifierThread() {
stopThread();
}
bool CSubsumptionClassifierThread::classify(CConcreteOntology *ontology, CConfigurationBase *config, const QList& requirementList, CCallbackData* callback) {
postEvent(new CClassifyOntologyEvent(ontology,config,requirementList,callback));
return true;
}
bool CSubsumptionClassifierThread::classify(CConcreteOntology *ontology, CConfigurationBase *config, const QList& requirementList) {
CBlockingCallbackData callback;
postEvent(new CClassifyOntologyEvent(ontology,config,requirementList,&callback));
callback.waitForCallback();
return true;
}
bool CSubsumptionClassifierThread::callbackClassified(CConcreteOntology *ontology, CCallbackData *callback) {
bool isClassifyOnto = false;
CTaxonomy *taxonomy = ontology->getConceptTaxonomy();
if (taxonomy && taxonomy->isComplete()) {
isClassifyOnto = true;
if (callback) {
callback->doCallback();
}
} else {
CBlockingCallbackData callbackBlock;
postEvent(new CCallbackClassifiedOntologyEvent(ontology,&callbackBlock,callback));
callbackBlock.waitForCallback();
CClassifyingCallbackDataContext *classifyingContext = dynamic_cast(callbackBlock.getCallbackDataContext());
if (classifyingContext) {
isClassifyOnto = classifyingContext->isClassifying();
}
}
return isClassifyOnto;
}
CClassificationMessageDataObserver* CSubsumptionClassifierThread::tellClassificationMessage(CConcreteOntology *ontology, CClassificationMessageData* messageData, CMemoryPool* memoryPool) {
postEvent(new COntologyTellClassificationMessageEvent(ontology,messageData,memoryPool));
return this;
}
CSubsumptionClassifierThread *CSubsumptionClassifierThread::addOntologyClassifiedCallback(CConcreteOntology *ontology, CCallbackData *callback) {
COntologyClassificationItem *ontClassItem = ontItemHash.value(ontology,0);
if (ontClassItem) {
ontClassItem->addClassifiedCallback(callback);
}
return this;
}
CSubsumptionClassifierThread* CSubsumptionClassifierThread::addOntologyClassifyRequirements(CConcreteOntology *ontology, const QList& requirementList) {
COntologyClassificationItem *ontClassItem = ontItemHash.value(ontology,nullptr);
if (ontClassItem) {
ontClassItem->addOntologyProcessingRequirements(requirementList);
}
return this;
}
CSubsumptionClassifierThread *CSubsumptionClassifierThread::scheduleOntologyClassification(CConcreteOntology *ontology, CClassificationCalculationSupport *classificationSupport, CConfigurationBase *config) {
COntologyClassificationItem *ontClassItem = new COntologyClassificationItem(config,statistics);
ontItemList.append(ontClassItem);
processingOntItemList.append(ontClassItem);
ontItemHash.insert(ontology,ontClassItem);
return this;
}
CSubsumptionClassifierThread* CSubsumptionClassifierThread::rescheduleOntologyClassification(CConcreteOntology *ontology) {
COntologyClassificationItem *ontClassItem = ontItemHash.value(ontology);
processingOntItemList.append(ontClassItem);
return this;
}
bool CSubsumptionClassifierThread::isOntologyClassificationScheduled(CConcreteOntology *ontology) {
return ontItemHash.contains(ontology);
}
bool CSubsumptionClassifierThread::canProcessMoreTests() {
return currRunningTestParallelCount < confMaxTestParallelCount;
}
bool CSubsumptionClassifierThread::startProcessMoreTests() {
return currRunningTestParallelCount <= confMinTestParallelCount;
}
bool CSubsumptionClassifierThread::doNextPendingTests() {
bool createdNewTests = false;
if (startProcessMoreTests()) {
bool nextTestCreated = true;
while (canProcessMoreTests() && nextTestCreated) {
nextTestCreated = false;
bool workCreated = createNextSubsumtionTest();
if (workCreated) {
nextTestCreated = true;
createdNewTests = true;
} else {
nextTestCreated = false;
}
}
}
submitCalculationJobs();
return createdNewTests;
}
CSubsumptionClassifierThread* CSubsumptionClassifierThread::submitCalculationJobs() {
if (!mJobCallbackList.isEmpty()) {
calculationManager->calculateJobs(mJobCallbackList);
mJobCallbackList.clear();
}
return this;
}
CSubsumptionClassifierThread* CSubsumptionClassifierThread::processCalculationJob(CSatisfiableCalculationJob* job, COntologyClassificationItem *ontClassItem, CCallbackData* callback, bool directlySubmit) {
currRunningTestParallelCount++;
++mStatCalculatingJobs;
if (!calculationManager) {
calculationManager = reasoner->getCalculationManager();
}
if (!calculationManager || directlySubmit || currRunningTestParallelCount-1 < confMinTestParallelCount/2) {
if (calculationManager) {
calculationManager->calculateJob(job,callback);
} else {
reasoner->reasoningSatisfiableCalcualtionJob(job,callback);
}
} else {
mJobCallbackList.append(QPair(job,callback));
}
return this;
}
bool CSubsumptionClassifierThread::processToldClassificationMessage(COntologyClassificationItem *ontClassItem, CClassificationMessageData* messageData, CMemoryPool* memoryPools) {
return false;
}
bool CSubsumptionClassifierThread::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (CThread::processCustomsEvents(type,event)) {
return true;
} else if (type == CClassifyOntologyEvent::EVENTTYPE) {
CClassifyOntologyEvent *coe = (CClassifyOntologyEvent *)event;
CConcreteOntology* onto = coe->getOntology();
CCallbackData *callback = coe->getCallbackData();
CConfigurationBase* config = coe->getConfiguration();
QList* reqList = coe->getClassificationRequirementList();
if (!isOntologyClassificationScheduled(onto)) {
scheduleOntologyClassification(onto,nullptr,config);
addOntologyClassifyRequirements(onto,*reqList);
} else {
rescheduleOntologyClassification(onto);
}
if (reqList) {
addOntologyClassifyRequirements(onto,*reqList);
}
if (callback) {
addOntologyClassifiedCallback(onto,callback);
}
doNextPendingTests();
return true;
} else if (type == COntologyTellClassificationMessageEvent::EVENTTYPE) {
COntologyTellClassificationMessageEvent *otcme = (COntologyTellClassificationMessageEvent *)event;
CConcreteOntology *ontology = otcme->getOntology();
COntologyClassificationItem *ontClassItem = ontItemHash.value(ontology,0);
if (ontClassItem) {
CClassificationMessageData* messageData = otcme->getMessageData();
CMemoryPool* memoryPools = otcme->getMemoryPool();
processToldClassificationMessage(ontClassItem,messageData,memoryPools);
mContext.getMemoryPoolAllocationManager()->releaseTemporaryMemoryPools(memoryPools);
}
doNextPendingTests();
return true;
} else if (type == CTestCalculatedCallbackEvent::EVENTTYPE) {
CTestCalculatedCallbackEvent *tcue = (CTestCalculatedCallbackEvent *)event;
interpreteTestResults(tcue);
currRunningTestParallelCount--;
doNextPendingTests();
return true;
} else if (type == CCallbackClassifiedOntologyEvent::EVENTTYPE) {
CCallbackClassifiedOntologyEvent *ccoe = (CCallbackClassifiedOntologyEvent *)event;
CCallbackData *possCallback = ccoe->getCallbackPossibleCallbackData();
COntologyClassificationItem *ontClassItem = ontItemHash.value(ccoe->getOntology(),0);
if (possCallback) {
CClassifyingCallbackDataContext *possCallbackContext = new CClassifyingCallbackDataContext(ontClassItem,ccoe->getOntology());
possCallback->setCallbackDataContext(possCallbackContext);
possCallback->doCallback();
}
CCallbackData *classifiedCallback = ccoe->getClassifiedCallbackData();
if (classifiedCallback) {
addOntologyClassifiedCallback(ccoe->getOntology(),classifiedCallback);
rescheduleOntologyClassification(ccoe->getOntology());
}
return true;
}
return false;
}
CClassifierStatistics *CSubsumptionClassifierThread::getClassificationStatistics() {
return statistics;
}
CClassificationProgress* CSubsumptionClassifierThread::getClassificationProgress() {
return nullptr;
}
bool CSubsumptionClassifierThread::isClassifierActive() {
return isThreadProcessingEvents();
}
}; // end namespace Classifier
}; // end namespace Reasoner
}; // end namespace Konclude