/* * 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 "CAnsweringManagerThread.h" namespace Konclude { namespace Reasoner { namespace Answerer { CAnsweringManagerThread::CAnsweringManagerThread(CReasonerManager* reasonerManager, CConfiguration* config) : CThread("Answerer-Manager-Thread"), mHandlerProvider(new CConfigurationAnsweringHandlerFactory(config)) { mConfig = config; mConfMaxThreadCount = 2; mCurrentThreadCount = 0; mCompositionQueryProcessingCount = 0; mMaxCompositionQueryProcessingCount = 1; mReasonerManager = reasonerManager; if (mQueuedThreadList.isEmpty() && mCurrentThreadCount < mConfMaxThreadCount) { CAnswererThread* answererThread = new CAnswererThread(mReasonerManager); answererThread->initializeAnswerer(mConfig); mQueuedThreadList.append(answererThread); mAnswererThreadContainer.append(answererThread); ++mCurrentThreadCount; } startThread(QThread::HighPriority); } CAnsweringManagerThread::~CAnsweringManagerThread() { stopThread(); } CAnsweringManager* CAnsweringManagerThread::answerComplexQuery(CComplexAnsweringQuery* complexAnsweringQuery, CCallbackData* callback) { postEvent(new CAnswerComplexQueryEvent(complexAnsweringQuery, callback)); return this; } CAnsweringProgress* CAnsweringManagerThread::getAnsweringProgress() { CAnsweringProgress newAnsweringProg; double percentAvg = 0; cint64 percentCount = 0; mReadWriteLock.lockForRead(); for (CAnswererThread* answererThread : mAnswererThreadContainer) { CAnsweringProgress* answeringProgress = answererThread->getAnsweringProgress(); if (answeringProgress) { newAnsweringProg.setTotalInstances(newAnsweringProg.getTotalInstances() + answeringProgress->getTotalInstances()); newAnsweringProg.setTestedInstances(newAnsweringProg.getTestedInstances() + answeringProgress->getTestedInstances()); newAnsweringProg.setRemainingMilliSeconds(qMax(newAnsweringProg.getRemainingMilliSeconds(), answeringProgress->getRemainingMilliSeconds())); percentAvg += answeringProgress->getProgessPercent(); ++percentCount; } } mReadWriteLock.unlock(); if (percentCount != 0) { percentAvg /= (double)percentCount; } newAnsweringProg.setProgessPercent(percentAvg); mAnsweringProgress = newAnsweringProg; return &mAnsweringProgress; } CAnsweringStatistics* CAnsweringManagerThread::getAnsweringStatistics(CConcreteOntology* ontology) { CAnsweringStatisticsCollectionStrings* stats = new CAnsweringStatisticsCollectionStrings(); mHandlerProvider.addAnsweringStatistics(ontology, stats); return stats; } CAnsweringManager* CAnsweringManagerThread::finishComplexQueryAnswering(CAnsweringHandler* answeringHandler, CAnsweringManagerQueryData* queryData) { mHandlerProvider.releaseAnsweringHandler(answeringHandler); if (queryData) { if (queryData->isCompositionQuery()) { --mCompositionQueryProcessingCount; } mProcessingQuerySet.remove(queryData); CAnswererThread* thread1 = queryData->getThread(); mProcessingThreadSet.remove(thread1); mQueuedThreadList.append(thread1); CCallbackData* callback = queryData->getCallback(); if (callback) { callback->doCallback(); } delete queryData; } return this; } CAnsweringManager* CAnsweringManagerThread::queueComplexQueryAnswering(CComplexAnsweringQuery* complexAnsweringQuery, CCallbackData* callback) { bool compositionQuery = dynamic_cast(complexAnsweringQuery); CAnsweringManagerQueryData* queryData = new CAnsweringManagerQueryData(complexAnsweringQuery, callback, compositionQuery); if (compositionQuery) { mQueuedCompositionQueryList.append(queryData); } else { mQueuedExpressionQueryList.append(queryData); } return this; } CAnsweringManager* CAnsweringManagerThread::manageComplexQueryAnswering() { if (!mQueuedExpressionQueryList.isEmpty() || !mQueuedCompositionQueryList.isEmpty()) { createQueuedAnswererThread(); if (!mQueuedThreadList.isEmpty()) { CAnsweringManagerQueryData* queryData = nullptr; if (!mQueuedExpressionQueryList.isEmpty()) { queryData = mQueuedExpressionQueryList.takeFirst(); } else if (!mQueuedCompositionQueryList.isEmpty() && mCompositionQueryProcessingCount < mMaxCompositionQueryProcessingCount) { queryData = mQueuedCompositionQueryList.takeFirst(); ++mCompositionQueryProcessingCount; } if (queryData) { CComplexAnsweringQuery* complexAnsweringQuery = queryData->getQuery(); CAnsweringHandler* handler = mHandlerProvider.getAnsweringHandler(complexAnsweringQuery); CAnswererThread* thread = mQueuedThreadList.takeFirst(); queryData->setThread(thread); mProcessingThreadSet.insert(thread); mProcessingQuerySet.insert(queryData); CAnsweringComplexQueryCompletedEvent* completedEventCallback = new CAnsweringComplexQueryCompletedEvent(this, handler, queryData); thread->handleAnswering(handler, complexAnsweringQuery, completedEventCallback); } } } return this; } CAnsweringManager* CAnsweringManagerThread::prepareAnswering(CConcreteOntology* ontology, CCallbackData* callback) { postEvent(new CAnsweringOntologyPreparationEvent(ontology, callback)); return this; } bool CAnsweringManagerThread::processCustomsEvents(QEvent::Type type, CCustomEvent *event) { if (CThread::processCustomsEvents(type, event)) { return true; } else if (type == CAnsweringOntologyPreparationEvent::EVENTTYPE) { CAnsweringOntologyPreparationEvent* ape = (CAnsweringOntologyPreparationEvent *)event; createQueuedAnswererThread(); if (!mQueuedThreadList.isEmpty()) { CConcreteOntology* ontology = ape->getOntology(); CAnsweringHandler* expressionHandler = mHandlerProvider.getAnsweringHandler(ontology, false); CAnswererThread* thread1 = mQueuedThreadList.takeFirst(); CAnsweringPreparedEvent* preparedEventCallback = new CAnsweringPreparedEvent(thread1, expressionHandler, this, ape->getCallbackData()); thread1->prepareAnswering(expressionHandler, preparedEventCallback); mProcessingThreadSet.insert(thread1); } else { ape->getCallbackData()->doCallback(); } createQueuedAnswererThread(); return true; } else if (type == CAnswerComplexQueryEvent::EVENTTYPE) { CAnswerComplexQueryEvent* acqe = (CAnswerComplexQueryEvent *)event; queueComplexQueryAnswering(acqe->getComplexQuery(), acqe->getCallbackData()); manageComplexQueryAnswering(); return true; } else if (type == CAnsweringComplexQueryCompletedEvent::EVENTTYPE) { CAnsweringComplexQueryCompletedEvent* acqce = (CAnsweringComplexQueryCompletedEvent *)event; finishComplexQueryAnswering(acqce->getAnsweringHandler(), acqce->getQueryData()); manageComplexQueryAnswering(); return true; } else if (type == CAnsweringPreparedEvent::EVENTTYPE) { CAnsweringPreparedEvent* ape = (CAnsweringPreparedEvent *)event; CAnswererThread* thread = ape->getAnswererThread(); mProcessingThreadSet.remove(thread); mQueuedThreadList.append(thread); mHandlerProvider.releaseAnsweringHandler(ape->getAnsweringHandler()); ape->getPreparedCallback()->doCallback(); manageComplexQueryAnswering(); return true; } return false; } void CAnsweringManagerThread::createQueuedAnswererThread() { if (mQueuedThreadList.isEmpty() && mCurrentThreadCount < mConfMaxThreadCount) { CAnswererThread* answererThread = new CAnswererThread(mReasonerManager); answererThread->initializeAnswerer(mConfig); mQueuedThreadList.append(answererThread); mReadWriteLock.lockForWrite(); mAnswererThreadContainer.append(answererThread); mReadWriteLock.unlock(); ++mCurrentThreadCount; } } }; // end namespace Answerer }; // end namespace Reasoner }; // end namespace Konclude