/*
* 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 "CAnswererThread.h"
namespace Konclude {
namespace Reasoner {
namespace Answerer {
CAnswererThread::CAnswererThread(CReasonerManager *reasonerManager) : CThread("Answerer-Thread") {
mReasonerManager = reasonerManager;
mCalculationManager = 0;
mCurrRunningTestParallelCount = 0;
mCurrRunningRequirementParallelCount = 0;
mConfMaxTestParallelCount = 1;
mConfMinTestParallelCount = 15;
mStatCalculationJobsSubmitted = 0;
mConfDirectSubmission = false;
mOccStatsCacheReader = nullptr;
mAnswererContext = new CAnswererContext(this);
startThread(QThread::HighPriority);
}
CAnswererThread::~CAnswererThread() {
stopThread();
}
CAnswererThread* CAnswererThread::initializeAnswerer(CConfiguration* config) {
bool configErrorFlag = false;
cint64 processorCount = 1;
QString processorCountString = CConfigDataReader::readConfigString(config, "Konclude.Calculation.ProcessorCount", QString(), &configErrorFlag);
if (!configErrorFlag) {
if (processorCountString == "AUTO") {
processorCount = CThread::idealThreadCount();
}
else {
qint64 convertedWorkerCount = processorCountString.toInt(&configErrorFlag);
if (configErrorFlag) {
processorCount = convertedWorkerCount;
}
}
}
bool mulConfigErrorFlag = false;
cint64 multiplicator = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Answering.MultipliedUnitsParallelTestingCalculationCount", 1, &mulConfigErrorFlag);
mConfMaxTestParallelCount = processorCount*multiplicator;
bool maxConfigErrorFlag = false;
cint64 maxParallel = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Answering.MaximumParallelTestingCalculationCount", 1, &maxConfigErrorFlag);
if (!maxConfigErrorFlag) {
if (!mulConfigErrorFlag) {
mConfMaxTestParallelCount = qMin(mConfMaxTestParallelCount, maxParallel);
}
else {
mConfMaxTestParallelCount = maxParallel;
}
}
return this;
}
bool CAnswererThread::handleAnswering(CAnsweringHandler* answeringHandler, CComplexAnsweringQuery* query, CCallbackData* callback) {
postEvent(new CAnsweringInitializingEvent(answeringHandler, query, callback));
return true;
}
bool CAnswererThread::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (CThread::processCustomsEvents(type,event)) {
return true;
} else if (type == CAnsweringInitializingEvent::EVENTTYPE) {
CAnsweringInitializingEvent* aie = (CAnsweringInitializingEvent *)event;
CAnsweringHandler* answeringHandler = aie->getAnsweringHandler();
CCallbackData* callback = aie->getCallbackData();
CComplexAnsweringQuery* query = aie->getQuery();
CAnsweringHandlerData* answeringHandlingData = new CAnsweringHandlerData(answeringHandler, callback);
mHandlerHandlerDataHash.insert(answeringHandler, answeringHandlingData);
mQueuedAnsweringHandlerList.append(answeringHandlingData);
mReadWriteLock.lockForWrite();
mManagedAnsweringHandlerSet.insert(answeringHandlingData);
mReadWriteLock.unlock();
answeringHandlingData->mQueued = true;
answeringHandler->addAnsweringComplexQuery(query);
answeringHandler->initializeProcessing(mAnswererContext);
continueCalculationCreation();
return true;
} else if (type == CAnsweringMessageEvent::EVENTTYPE) {
CAnsweringMessageEvent* ame = (CAnsweringMessageEvent *)event;
CAnsweringHandler* answeringHandler = ame->getAnsweringHandler();
CAnsweringMessageData* messageData = ame->getMessageData();
CMemoryPool* memoryPool = ame->getMemoryPool();
answeringHandler->processCalculationMessage(messageData, mAnswererContext);
if (!memoryPool) {
//delete messageData;
} else {
mAnswererContext->getMemoryPoolProvider()->releaseMemoryPool(memoryPool);
}
continueCalculationCreation();
return true;
} else if (type == CAnsweringCalculationCompletedEvent::EVENTTYPE) {
--mCurrRunningTestParallelCount;
CAnsweringCalculationCompletedEvent* ame = (CAnsweringCalculationCompletedEvent *)event;
CAnsweringHandler* answeringHandler = ame->getAnsweringHandler();
CAnsweringMessageData* messageData = ame->getMessageData();
answeringHandler->processCalculationMessage(messageData, mAnswererContext);
CAnsweringHandlerData* handlerData = mHandlerHandlerDataHash.value(answeringHandler);
handlerData->mJobProcessingCount--;
if (!handlerData->mQueued) {
handlerData->mQueued = true;
mQueuedAnsweringHandlerList.prepend(handlerData);
}
//delete messageData;
continueCalculationCreation();
return true;
} else if (type == CAnsweringRequirementCompletedEvent::EVENTTYPE) {
//sleep(6);
--mCurrRunningRequirementParallelCount;
CAnsweringRequirementCompletedEvent* ame = (CAnsweringRequirementCompletedEvent *)event;
CAnsweringHandler* answeringHandler = ame->getAnsweringHandler();
CAnsweringMessageData* messageData = ame->getMessageData();
answeringHandler->processRequirementMessage(messageData, mAnswererContext);
CAnsweringHandlerData* handlerData = mHandlerHandlerDataHash.value(answeringHandler);
handlerData->mRequirmentProcessingCount--;
if (!handlerData->mQueued) {
handlerData->mQueued = true;
mQueuedAnsweringHandlerList.prepend(handlerData);
}
//delete messageData;
continueCalculationCreation();
return true;
} else if (type == CAnsweringHandlerPreparationEvent::EVENTTYPE) {
CAnsweringHandlerPreparationEvent* ape = (CAnsweringHandlerPreparationEvent *)event;
CAnsweringHandler* answeringHandler = ape->getAnsweringHandler();
if (answeringHandler) {
answeringHandler->prepareProcessing(mAnswererContext);
}
ape->getCallbackData()->doCallback();
return true;
}
return false;
}
CAnsweringMessageDataObserver* CAnswererThread::sendMessage(CAnsweringHandler* handler, CAnsweringMessageData* message, CMemoryPool* memoryPool) {
postEvent(new CAnsweringMessageEvent(handler, message, memoryPool));
return this;
}
CAnsweringCalculationHandler* CAnswererThread::postMessage(CAnsweringHandler* handler, CAnsweringMessageData* message) {
postEvent(new CAnsweringMessageEvent(handler, message, nullptr));
return this;
}
bool CAnswererThread::continueCalculationCreation() {
bool createdCalculationJobs = false;
if (!mQueuedAnsweringHandlerList.isEmpty() && mCurrRunningTestParallelCount < mConfMaxTestParallelCount) {
CAnsweringHandlerData* handlerData = mQueuedAnsweringHandlerList.first();
bool calculationCreated = false;
bool calculationCreationContinued = true;
while (calculationCreationContinued && mCurrRunningTestParallelCount < mConfMaxTestParallelCount) {
calculationCreationContinued = handlerData->mAnsweringHandler->continueCalculationCreation(mAnswererContext);
calculationCreated |= calculationCreationContinued;
}
if (calculationCreated) {
handlerData->mProcessing = true;
mProcessingAnsweringHandlerSet.insert(handlerData);
} else {
mProcessingAnsweringHandlerSet.remove(handlerData);
}
if (!calculationCreationContinued) {
handlerData->mQueued = false;
mQueuedAnsweringHandlerList.removeFirst();
if (handlerData->mAnsweringHandler->isAnsweringFinished(mAnswererContext)) {
mHandlerHandlerDataHash.remove(handlerData->mAnsweringHandler);
if (handlerData->mCallbackData) {
handlerData->mCallbackData->doCallback();
}
mProcessingAnsweringHandlerSet.remove(handlerData);
mReadWriteLock.lockForWrite();
mManagedAnsweringHandlerSet.remove(handlerData);
mReadWriteLock.unlock();
delete handlerData;
}
}
}
submitCalculationJobs();
return createdCalculationJobs;
}
CAnswererThread* CAnswererThread::submitCalculationJobs() {
if (!mJobCallbackList.isEmpty()) {
mCalculationManager->calculateJobs(mJobCallbackList);
mJobCallbackList.clear();
}
return this;
}
CAnsweringCalculationHandler* CAnswererThread::ensureRequirements(CAnsweringHandler* handler, CConcreteOntology* ontology, const QList& requirementList, CAnsweringMessageData* finishedMessage) {
++mStatRequirmentSubmitted;
++mCurrRunningRequirementParallelCount;
CAnsweringHandlerData* handlerData = mHandlerHandlerDataHash.value(handler);
handlerData->mRequirmentProcessingCount++;
CAnsweringRequirementCompletedEvent* callbackEvent = new CAnsweringRequirementCompletedEvent(this, handler, finishedMessage);
mReasonerManager->prepareOntology(ontology,requirementList,callbackEvent);
return this;
}
CAnsweringCalculationHandler* CAnswererThread::answerSubQuery(CAnsweringHandler* handler, CQuery* query, CAnsweringMessageData* finishedMessage) {
++mStatRequirmentSubmitted;
++mCurrRunningRequirementParallelCount;
CAnsweringHandlerData* handlerData = mHandlerHandlerDataHash.value(handler);
handlerData->mRequirmentProcessingCount++;
CAnsweringRequirementCompletedEvent* callbackEvent = new CAnsweringRequirementCompletedEvent(this, handler, finishedMessage);
mReasonerManager->reasoningQuery(query, callbackEvent);
return this;
}
CAnsweringCalculationHandler* CAnswererThread::postCalculation(CAnsweringHandler* handler, CSatisfiableCalculationJob* satCalcJob, CAnsweringMessageData* finishedMessage, CCallbackDataContext* callbackContext) {
++mStatCalculationJobsSubmitted;
CAnsweringHandlerData* handlerData = mHandlerHandlerDataHash.value(handler);
handlerData->mJobProcessingCount++;
CAnsweringCalculationCompletedEvent* callbackEvent = new CAnsweringCalculationCompletedEvent(this,handler,finishedMessage, callbackContext);
if (!mCalculationManager) {
mCalculationManager = mReasonerManager->getCalculationManager();
}
++mCurrRunningTestParallelCount;
if (!mCalculationManager || mConfDirectSubmission || mCurrRunningTestParallelCount - 1 < mConfMinTestParallelCount / 2) {
if (mCalculationManager) {
mCalculationManager->calculateJob(satCalcJob, callbackEvent);
} else {
mReasonerManager->reasoningSatisfiableCalcualtionJob(satCalcJob, callbackEvent);
}
} else {
mJobCallbackList.append(QPair(satCalcJob, callbackEvent));
}
return this;
}
COccurrenceStatisticsCacheReader* CAnswererThread::getOccurrenceStatisticsCacheReader() {
if (!mOccStatsCacheReader) {
COccurrenceStatisticsCache* occStatsCache = mReasonerManager->getOccurrenceStatisticsCache();
if (occStatsCache) {
mOccStatsCacheReader = occStatsCache->createCacheReader();
}
}
return mOccStatsCacheReader;
}
CAnswererThread* CAnswererThread::prepareAnswering(CAnsweringHandler* answeringHandler, CCallbackData* callback) {
postEvent(new CAnsweringHandlerPreparationEvent(answeringHandler, callback));
return this;
}
CAnsweringProgress* CAnswererThread::getAnsweringProgress() {
CAnsweringProgress newAnsweringProg;
double percentAvg = 0;
cint64 percentCount = 0;
mReadWriteLock.lockForRead();
for (CAnsweringHandlerData* answeringHandlerData : mManagedAnsweringHandlerSet) {
CAnsweringProgress* answeringProgress = answeringHandlerData->mAnsweringHandler->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;
}
CAnswererThread* CAnswererThread::addAnsweringStatistics(CAnsweringStatistics* stats) {
mReadWriteLock.lockForRead();
for (CAnsweringHandlerData* answeringHandlerData : mManagedAnsweringHandlerSet) {
answeringHandlerData->mAnsweringHandler->addAnsweringStatistics(stats, true);
}
mReadWriteLock.unlock();
return this;
}
}; // end namespace Answerer
}; // end namespace Reasoner
}; // end namespace Konclude