/* * 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 "CRealizerThread.h" namespace Konclude { namespace Reasoner { namespace Realizer { CRealizerThread::CRealizerThread(CReasonerManager *reasonerManager) : CThread("Realizer-Thread") { mReasoner = reasonerManager; mCalculationManager = 0; mCurrRunningTestParallelCount = 0; mConfMaxTestParallelCount = 1; mStatCalculatingJobs = 0; startThread(QThread::HighPriority); } CRealizerThread::~CRealizerThread() { stopThread(); } bool CRealizerThread::realize(CConcreteOntology* ontology, CConfigurationBase* config, const QList& requirementList, CCallbackData* callback) { postEvent(new CRealizeOntologyEvent(ontology,config,requirementList,callback)); return true; } bool CRealizerThread::realize(CConcreteOntology* ontology, CConfigurationBase* config, const QList& requirementList) { CBlockingCallbackData callback; postEvent(new CRealizeOntologyEvent(ontology,config,requirementList,&callback)); callback.waitForCallback(); return true; } bool CRealizerThread::callbackRealized(CConcreteOntology* ontology, CCallbackData* callback) { bool callbackRealizedOnto = false; CRealization* realization = ontology->getRealization(); if (realization && realization->isRealized()) { callbackRealizedOnto = true; if (callback) { callback->doCallback(); } } else { CBlockingCallbackData callbackBlock; postEvent(new CCallbackRealizedOntologyEvent(ontology,&callbackBlock,callback)); callbackBlock.waitForCallback(); CCallbackDataContext* callbackContext = callbackBlock.getCallbackDataContext(); if (callbackContext) { CRealizingCallbackDataContext* possCallbackContext = dynamic_cast(callbackContext); callbackRealizedOnto = possCallbackContext->isRealized(); } } return callbackRealizedOnto; } bool CRealizerThread::canProcessMoreTests() { return mCurrRunningTestParallelCount < mConfMaxTestParallelCount; } bool CRealizerThread::doNextPendingTests() { bool createdNewTests = false; bool nextTestCreated = true; while (canProcessMoreTests() && nextTestCreated) { nextTestCreated = false; bool workCreated = createNextTest(); if (workCreated) { nextTestCreated = true; createdNewTests = true; } else { nextTestCreated = false; } } return createdNewTests; } CRealizerThread* CRealizerThread::processCalculationJob(CSatisfiableCalculationJob* job, COntologyRealizingItem* preCompItem, CRealizingTestingItem* preTestItem) { CRealizingCalculatedCallbackEvent* callbackEvent = new CRealizingCalculatedCallbackEvent(this,job,preTestItem); preCompItem->getRealizingTestingItemSet()->insert(preTestItem); mCurrRunningTestParallelCount++; ++mStatCalculatingJobs; if (!mCalculationManager) { mCalculationManager = mReasoner->getCalculationManager(); } if (mCalculationManager) { mCalculationManager->calculateJob(job,callbackEvent); } else { mReasoner->reasoningSatisfiableCalcualtionJob(job,callbackEvent); } return this; } COntologyRealizingItem* CRealizerThread::initializeOntologyRealizingItem(CConcreteOntology* ontology, CConfigurationBase* config) { COntologyRealizingItem* item = new COntologyRealizingItem(); item->initRealizingItem(ontology,config); return item; } bool CRealizerThread::addOntologyRealizingCallback(COntologyRealizingItem* item, CCallbackData* callback) { item->addRealizingFinishedCallback(callback); return true; } bool CRealizerThread::addOntologyRealizingRequirements(COntologyRealizingItem* item, COntologyProcessingRequirement* requirement, COntologyRealizingDynamicRequirmentProcessingData* procData) { item->addProcessingRequirement(requirement, procData); return true; } CRealizationMessageObserver* CRealizerThread::tellRealizationMessage(CConcreteOntology *ontology, CRealizationMessageData* messageData, CMemoryPool* memoryPool) { postEvent(new CRealizationMessageEvent(ontology,messageData,memoryPool)); return this; } bool CRealizerThread::processCustomsEvents(QEvent::Type type, CCustomEvent* event) { if (CThread::processCustomsEvents(type,event)) { return true; } else if (type == CRealizationMessageEvent::EVENTTYPE) { CRealizationMessageEvent* otcme = (CRealizationMessageEvent *)event; CConcreteOntology* ontology = otcme->getOntology(); COntologyRealizingItem* ontRealItem = mOntItemHash.value(ontology,0); if (ontRealItem) { CRealizationMessageData* messageData = otcme->getMessageData(); CMemoryPool* memoryPools = otcme->getMemoryPool(); processRealizationMessage(ontRealItem,messageData,memoryPools); mContext.getMemoryPoolAllocationManager()->releaseTemporaryMemoryPools(memoryPools); } doNextPendingTests(); return true; } else if (type == CRealizeOntologyEvent::EVENTTYPE) { CRealizeOntologyEvent* poe = (CRealizeOntologyEvent*)event; CCallbackData* callbackData = poe->getCallbackData(); CConfigurationBase* configBase = poe->getConfiguration(); CConcreteOntology* ontology = poe->getOntology(); QList* requirementList = poe->getRealizingRequirementList(); COntologyRealizingItem* item = mOntItemHash.value(ontology); if (!item) { item = initializeOntologyRealizingItem(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); } } COntologyRealizingDynamicRequirmentCallbackData* callbackProcData = new COntologyRealizingDynamicRequirmentCallbackData(callbackData); callbackProcData->incProcessingRequirmentCount(requirementList->count()); for (QList::const_iterator it = requirementList->constBegin(), itEnd = requirementList->constEnd(); it != itEnd; ++it) { COntologyProcessingRequirement* requ(*it); COntologyRealizingDynamicRequirmentProcessingData* procData = new COntologyRealizingDynamicRequirmentProcessingData(requ, callbackProcData); addOntologyRealizingRequirements(item, requ, procData); } item->logRequirementProcessingStartStatistics(callbackProcData->getStatistics()); //for (QList::const_iterator it = requirementList->constBegin(), itEnd = requirementList->constEnd(); it != itEnd; ++it) { // COntologyProcessingRequirement* requ(*it); // addOntologyRealizingRequirements(item,requ, procData); //} //if (callbackData) { // addOntologyRealizingCallback(item, callbackData); //} doNextPendingTests(); return true; } else if (type == CCallbackRealizedOntologyEvent::EVENTTYPE) { CCallbackRealizedOntologyEvent* cpoe = (CCallbackRealizedOntologyEvent*)event; CConcreteOntology* ontology = cpoe->getOntology(); CCallbackData* realizeedCallbackData = cpoe->getRealizedCallbackData(); CCallbackData* installedCallbackData = cpoe->getCallbackPossibleCallbackData(); COntologyRealizingItem* item = mOntItemHash.value(ontology); if (item) { addOntologyRealizingCallback(item,realizeedCallbackData); if (installedCallbackData) { CRealizingCallbackDataContext* callbackDataContext = new CRealizingCallbackDataContext(true,ontology); installedCallbackData->setCallbackDataContext(callbackDataContext); installedCallbackData->doCallback(); } } else { if (installedCallbackData) { CRealizingCallbackDataContext* callbackDataContext = new CRealizingCallbackDataContext(false,ontology); installedCallbackData->setCallbackDataContext(callbackDataContext); installedCallbackData->doCallback(); } } return true; } else if (type == CRealizingCalculatedCallbackEvent::EVENTTYPE) { CRealizingCalculatedCallbackEvent* pcce = (CRealizingCalculatedCallbackEvent*)event; --mCurrRunningTestParallelCount; CRealizingTestingItem* testingItem = pcce->getTestingItem(); COntologyRealizingItem* ontPreproItem = testingItem->getOntologyRealizingItem(); ontPreproItem->getRealizingTestingItemSet()->remove(testingItem); realizingTested(ontPreproItem,testingItem,pcce); doNextPendingTests(); return true; } return false; } }; // end namespace Realizer }; // end namespace Reasoner }; // end namespace Konclude