/*
* 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 "CTaskProcessorThreadBase.h"
namespace Konclude {
namespace Scheduler {
CTaskProcessorThreadBase::CTaskProcessorThreadBase(CTaskHandleAlgorithm* taskHandleAlgo, const QString &threadStringName) : CThread(threadStringName) {
mTaskProcessingQueue = nullptr;
mTaskSchedulingQueue = nullptr;
mTaskCompletionQueue = nullptr;
mMemoryAllocator = nullptr;
mTaskProcessorContext = nullptr;
mTaskStatusPropagator = nullptr;
mCallbackExecuter = nullptr;
mTaskHandleAlgo = taskHandleAlgo;
mProcessingBlocked = true;
mEventHandler = new CQueuedLinkedEventHandler(this,this);
CXLinker* eventHandlerLinker = new CXLinker(mEventHandler,nullptr);
mEventHandlerLinker = eventHandlerLinker;
mTaskReserveQueueConsumer = nullptr;
mProcessingStopped = false;
mThreadBlocked = false;
mStatComputionTime = 0;
mStatBlockingTime = 0;
mLastProcessingStartedTag = 0;
mLastProcessingStartRequestTag = 0;
mTaskProcessingCount = 0;
mEventSignalized = false;
mProcessTaskRequesting = true;
mTaskSchedulingCount = 0;
mCriticalSchedulingCount = 3;
mCriticalSchedulingThresholdCount = 5;
mCriticalSchedulingNotified = true;
mRecievedTasks = 0;
mTaskReserveQueueCount = 0;
mTaskParentRelevantCount = 0;
mConfScheduleTasksDistribution = false;
mConfProcessingTasksDistribution = false;
mConfUseReserveTasksQueue = true;
mMinimalPriorityTaskInvalidated = false;
mMinTaskPriority = 0.;
mMinPriorityTask = nullptr;
mConfProcessSchedulingTasks = true;
mConfProcessReserveTasks = true;
// for debugging only
mLastProcessedTask = nullptr;
mLastDispendedTask = nullptr;
mLastProcessedEvent = nullptr;
}
CTaskProcessorThreadBase::~CTaskProcessorThreadBase() {
}
CTaskHandleAlgorithm* CTaskProcessorThreadBase::getTaskHandleAlgorithm() {
return mTaskHandleAlgo;
}
bool CTaskProcessorThreadBase::isProcessing() {
return !mProcessingBlocked;
}
bool CTaskProcessorThreadBase::isBlocked() {
return mProcessingBlocked;
}
CTaskProcessorThreadBase* CTaskProcessorThreadBase::installCallbackExecuter(CTaskCallbackExecuter* callbackExecuter) {
mCallbackExecuter = callbackExecuter;
return this;
}
CTaskProcessorThreadBase* CTaskProcessorThreadBase::installStatusPropagator(CTaskStatusPropagator* statusPropagator) {
mTaskStatusPropagator = statusPropagator;
return this;
}
CTaskProcessingStatistics* CTaskProcessorThreadBase::getTaskProcessingStatistics() {
return &mStats;
}
cint64 CTaskProcessorThreadBase::getStatisticBlockingTime() {
cint64 blockTime = mStatBlockingTime;
#ifdef KONCLUDE_SCHEDULER_TASK_THREADS_TIME_STATISTICS
if (mThreadBlocked) {
blockTime += mBlockingTimer.elapsed();
}
#endif
return blockTime;
}
cint64 CTaskProcessorThreadBase::getStatisticComputionTime() {
cint64 compTime = mStatComputionTime;
#ifdef KONCLUDE_SCHEDULER_TASK_THREADS_TIME_STATISTICS
if (!mThreadBlocked) {
compTime += mComputionTimer.elapsed();
}
#endif
return compTime;
}
CEventHandler* CTaskProcessorThreadBase::getEventHandler() {
return mEventHandler;
}
bool CTaskProcessorThreadBase::canDispenseProcessingTasks() {
return mTaskProcessingCount+mTaskSchedulingCount >= 2;
}
bool CTaskProcessorThreadBase::requiresProcessingTasks() {
return mTaskProcessingCount+mTaskSchedulingCount <= 0;
}
bool CTaskProcessorThreadBase::requiresSchedulingTasks() {
return mCriticalSchedulingNotified;
}
cint64 CTaskProcessorThreadBase::countDispensableProcessingTasks() {
return mTaskProcessingCount+mTaskSchedulingCount;
}
cint64 CTaskProcessorThreadBase::countScheduleableProcessingTasks() {
return mTaskSchedulingCount;
}
cint64 CTaskProcessorThreadBase::getRecievedTasks() {
return mRecievedTasks;
}
CTaskProcessorThreadBase* CTaskProcessorThreadBase::startProcessing() {
if (!isRunning()) {
startThread(QThread::HighPriority);
postEvent(new Concurrent::Events::CHandleEventsEvent());
}
return this;
}
CTaskProcessorThreadBase* CTaskProcessorThreadBase::stopProcessing() {
mProcessingStopped = true;
return this;
}
CThreadActivator* CTaskProcessorThreadBase::signalizeEvent() {
mEventSignalized = true;
if (mProcessingBlocked) {
// reactivate processing
if (mLastProcessingStartedTag == mLastProcessingStartRequestTag) {
++mLastProcessingStartRequestTag;
mProcessingWakeUpSemaphore.release();
}
}
return this;
}
bool CTaskProcessorThreadBase::processControlEvents(QEvent::Type type, CControlEvent *event) {
if (CThread::processControlEvents(type,event)) {
return true;
} else {
if (type == Concurrent::Events::CHandleEventsEvent::EVENTTYPE) {
#ifdef KONCLUDE_SCHEDULER_TASK_THREADS_TIME_STATISTICS
mComputionTimer.start();
#endif
processingLoop();
return true;
}
}
return false;
}
bool CTaskProcessorThreadBase::processingLoop() {
bool eventSafeguardProcessed = false;
while (!mProcessingStopped) {
if (!mTaskProcessingQueue && mProcessingBlocked) {
// block until new events or task are available
#ifdef KONCLUDE_SCHEDULER_TASK_THREADS_TIME_STATISTICS
mStatComputionTime += mComputionTimer.elapsed();
mBlockingTimer.start();
#endif
INCTASKPROCESSINGSTAT(mStats.incStatisticThreadsBlockedCount(1));
mThreadBlocked = true;
mProcessingWakeUpSemaphore.tryAcquire(1,100);
mThreadBlocked = false;
#ifdef KONCLUDE_SCHEDULER_TASK_THREADS_TIME_STATISTICS
mStatBlockingTime += mBlockingTimer.elapsed();
mComputionTimer.start();
#endif
mLastProcessingStartedTag = mLastProcessingStartRequestTag;
}
mProcessingBlocked = false;
eventSafeguardProcessed = false;
while (mEventSignalized) {
bool eventsProcessed = handleEvents();
}
if (mTaskProcessingQueue) {
CTask* processingTask = mTaskProcessingQueue;
mTaskProcessingQueue = mTaskProcessingQueue->getNext();
--mTaskProcessingCount;
cint64 taskDepth = processingTask->getTaskDepth();
bool continueProcessing = processTask(processingTask);
if (continueProcessing) {
addProcessingTask(processingTask);
} else {
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksProcessedDepthCount(taskDepth,1));
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksProcessedCount(1));
}
}
if (!mTaskProcessingQueue && mTaskSchedulingQueue && mConfProcessSchedulingTasks) {
CTask* nextTask = mTaskSchedulingQueue;
mTaskSchedulingQueue = mTaskSchedulingQueue->getNext();
nextTask->clearNext();
--mTaskSchedulingCount;
addProcessingTask(nextTask);
if (!mCriticalSchedulingNotified && mTaskSchedulingCount <= mCriticalSchedulingCount) {
mCriticalSchedulingNotified = true;
processCriticalScheduleTask();
}
}
if (!mTaskProcessingQueue && mConfProcessReserveTasks) {
if (mConfUseReserveTasksQueue && mTaskReserveQueueConsumer) {
CTask* task = mTaskReserveQueueConsumer->getTask();
if (task) {
++mTaskReserveQueueCount;
addProcessingTask(task);
}
}
}
processDispenseNotification();
if (!mTaskProcessingQueue) {
while (mEventSignalized || !eventSafeguardProcessed) {
bool eventsProcessed = handleEvents();
if (eventsProcessed) {
eventSafeguardProcessed = false;
mProcessingBlocked = false;
} else if (!mProcessingBlocked) {
mProcessingBlocked = true;
} else if (!eventSafeguardProcessed) {
eventSafeguardProcessed = true;
}
}
if (!mTaskProcessingQueue && !mProcessTaskRequesting) {
mProcessTaskRequesting = true;
processRequestProcessTask();
}
}
}
return true;
}
bool CTaskProcessorThreadBase::addProcessingTask(CTask* task) {
if (task) {
CTask* taskIt = task;
cint64 taskCount = 0;
double minPriority = 0.;
CTask* minPriorityTask = nullptr;
while (taskIt) {
taskIt->getTaskStatus()->setTaskQUEUEDState();
if (!minPriorityTask || taskIt->getTaskPriority() < minPriority) {
minPriority = taskIt->getTaskPriority();
minPriorityTask = taskIt;
}
++taskCount;
taskIt = taskIt->getNext();
}
if (minPriorityTask) {
if (minPriority < mMinTaskPriority) {
mMinimalPriorityTaskInvalidated = true;
}
}
mTaskProcessingCount += taskCount;
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksAddedCount(1));
if (!mTaskProcessingQueue) {
mTaskProcessingQueue = task;
task = task->getNext();
mTaskProcessingQueue->clearNext();
}
if (task) {
mTaskProcessingQueue = mTaskProcessingQueue->insertNextSorted(task);
}
mProcessTaskRequesting = false;
return true;
}
return false;
}
bool CTaskProcessorThreadBase::processEvent(CEvent *event, CContext* handlerContext) {
mLastProcessedEvent = event;
cint64 eventID = event->getEventTypeID();
if (eventID == CSendTaskProcessEvent::EVENTTYPEID) {
CSendTaskProcessEvent* sendTaskProcessEvent = (CSendTaskProcessEvent*)event;
CTask* task = sendTaskProcessEvent->getTask();
bool schedulable = sendTaskProcessEvent->isSchedulingTask();
++mRecievedTasks;
if (!mTaskProcessingQueue || !schedulable) {
addProcessingTask(task);
} else {
++mTaskSchedulingCount;
if (mTaskSchedulingQueue) {
mTaskSchedulingQueue = mTaskSchedulingQueue->append(task);
} else {
mTaskSchedulingQueue = task;
}
if (mTaskSchedulingCount >= mCriticalSchedulingThresholdCount) {
mCriticalSchedulingNotified = false;
}
}
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CSendTaskCompleteEvent::EVENTTYPEID) {
CTask* task = ((CSendTaskCompleteEvent*)event)->getTask();
processCompleteTask(task);
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CTaskAdditionalAllocationEvent::EVENTTYPEID) {
CTaskAdditionalAllocationEvent* taskAddAllocEvent = (CTaskAdditionalAllocationEvent*)event;
CTask* task = taskAddAllocEvent->getTask();
CMemoryPool* addMemoryPools = taskAddAllocEvent->getAdditionalAllocatedMemoryPools();
processAdditionalTaskAllocation(task,addMemoryPools);
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CRequestScheduleTaskEvent::EVENTTYPEID) {
CTaskScheduleItem* taskScheduleItem = ((CRequestScheduleTaskEvent*)event)->getTaskScheduleItem();
mMemoryAllocator->releaseMemoryPoolContainer(event);
CTask* responseTask = mTaskSchedulingQueue;
bool schedulingTask = false;
if (responseTask) {
--mTaskSchedulingCount;
schedulingTask = true;
mTaskSchedulingQueue = mTaskSchedulingQueue->getNext();
if (!mCriticalSchedulingNotified && mTaskSchedulingCount <= mCriticalSchedulingCount) {
mCriticalSchedulingNotified = true;
processCriticalScheduleTask();
}
} else {
if (mConfProcessingTasksDistribution) {
CTask* lastTask = nullptr;
CTask* taskIt = mTaskProcessingQueue;
// response least priority task
while (taskIt && taskIt->hasNext()) {
lastTask = taskIt;
taskIt = taskIt->getNext();
}
if (lastTask) {
responseTask = lastTask->getNext();
lastTask->clearNext();
--mTaskProcessingCount;
}
} else if (mConfProcessingTasksDistribution) {
CTask* lastBeforeRelevantTask = nullptr;
CTask* lastTask = nullptr;
CTask* taskIt = mTaskProcessingQueue;
// response least priority task which is relevant
while (taskIt && taskIt->hasNext()) {
lastTask = taskIt;
CTask* parentTask = taskIt->getParentTask();
if (!parentTask || parentTask->isTaskRelevant()) {
lastBeforeRelevantTask = lastTask;
}
taskIt = taskIt->getNext();
}
if (lastBeforeRelevantTask) {
responseTask = lastBeforeRelevantTask->getNext();
lastBeforeRelevantTask->setNext(responseTask->getNext());
responseTask->clearNext();
--mTaskProcessingCount;
--mTaskParentRelevantCount;
}
}
if (responseTask) {
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksRequestedCount(1));
responseTask->clearTaskOwner();
CTask* parentTask = responseTask->getParentTask();
while (parentTask) {
if (parentTask->hasTaskOwner()) {
parentTask->clearTaskOwner();
parentTask = parentTask->getParentTask();
} else {
parentTask = nullptr;
}
}
mLastDispendedTask = responseTask;
responseTask->getTaskStatus()->setTaskSCHEDULINGState();
}
}
if (responseTask) {
responseTask->clearNext();
}
processResponseScheduleTask(responseTask,taskScheduleItem,schedulingTask);
return true;
} else if (eventID == CUpdateTaskStatusEvent::EVENTTYPEID) {
CUpdateTaskStatusEvent* utse = (CUpdateTaskStatusEvent*)event;
processUpdateTaskStatus(utse->getParentTask(),utse->getUpdateTask());
return true;
} else {
// not supported
}
return false;
}
void CTaskProcessorThreadBase::organizeDispenseTasks(bool forceUpdate) {
if (mMinimalPriorityTaskInvalidated || forceUpdate) {
// count dispense task and find minimal priority
CTask* taskIt = mTaskProcessingQueue;
double minPriority = 0.;
CTask* minPriorityTask = nullptr;
cint64 dispenseTaskCount = 0;
while (taskIt) {
CTask* task = taskIt;
if (task->isTaskDispenseMarked()) {
++dispenseTaskCount;
double priorty = task->getTaskPriority();
if (!minPriorityTask || minPriority < priorty) {
minPriority = priorty;
minPriorityTask = task;
}
}
taskIt = taskIt->getNext();
}
mMinTaskPriority = minPriority;
mMinPriorityTask = minPriorityTask;
mMinimalPriorityTaskInvalidated = false;
}
}
CTaskProcessorCommunicator* CTaskProcessorThreadBase::communicateTaskComplete(CTask* task) {
task->getTaskStatus()->setTaskFINISHEDState();
processCompleteTask(task);
return this;
}
CTaskProcessorCommunicator* CTaskProcessorThreadBase::communicateTaskError(CTask* task) {
task->getTaskStatus()->setTaskFINISHEDState();
processCompleteTask(task);
return this;
}
CTaskProcessorCommunicator* CTaskProcessorThreadBase::communicateTaskCreation(CTask* newTask) {
CTask* taskIt = newTask;
while (taskIt) {
if (!taskIt->hasTaskOwner()) {
taskIt->setTaskOwner(this);
}
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCreatedCount(1));
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCreatedDepthCount(taskIt->getTaskDepth(),1));
taskIt = taskIt->getNext();
}
addProcessingTask(newTask);
return this;
}
CTaskProcessorCommunicator* CTaskProcessorThreadBase::communicateTaskStatusUpdate(CTask* task) {
processUpdateTaskStatus(task);
return this;
}
CTaskProcessorCommunicator* CTaskProcessorThreadBase::communicateTaskRelevant(CTask* task) {
// TODO: mark task as relevant and prepare for distribution
if (!task->isTaskRelevant()) {
if (task->hasNoTaskOwnerAndNoParentTask() || task->hasTaskOwner(this)) {
task->setTaskRelevant(true);
CXNegLinker* refTaskLinker = task->getReferencedTaskLinker();
while (refTaskLinker) {
bool refTaskCompleted = !refTaskLinker->isNegated();
if (!refTaskCompleted) {
CTask* refTask = refTaskLinker->getData();
if (refTask->getTaskStatus()->isTaskStateQUEUED()) {
++mTaskParentRelevantCount;
}
}
refTaskLinker = refTaskLinker->getNext();
}
}
}
return this;
}
CTaskProcessorCommunicator* CTaskProcessorThreadBase::communicateTaskAdditionalAllocation(CTask* task, CMemoryPool* additionalAllocatedMemoryPool) {
processAdditionalTaskAllocation(task,additionalAllocatedMemoryPool);
return this;
}
bool CTaskProcessorThreadBase::verifyContinueTaskProcessing(CTask* task) {
if (mEventSignalized) {
return false;
}
if (!task->getTaskStatus()->isProcessable()) {
return false;
}
if (mTaskProcessingQueue && mTaskProcessingQueue->getTaskPriority() > task->getTaskPriority()) {
return false;
}
return true;
}
bool CTaskProcessorThreadBase::handleEvents() {
bool handleNextRound = true;
bool roundEventProcessed = false;
bool eventProcessed = false;
while (handleNextRound && !mProcessingStopped) {
roundEventProcessed = false;
CXLinker* eventHandlerLinkerIt = mEventHandlerLinker;
if (eventHandlerLinkerIt) {
CEventHandler* eventHandler = eventHandlerLinkerIt->getData();
if (eventHandler->needEventProcessing()) {
cint64 handledEventCount = eventHandler->handleEvents(mTaskProcessorContext);
INCTASKPROCESSINGSTAT(mStats.incStatisticEventsProcessedCount(handledEventCount));
roundEventProcessed = handledEventCount > 0;
}
// round robin
eventHandlerLinkerIt = eventHandlerLinkerIt->getNext();
if (!eventHandlerLinkerIt) {
if (mEventSignalized || roundEventProcessed) {
handleNextRound = true;
mEventSignalized = false;
} else {
handleNextRound = false;
}
eventHandlerLinkerIt = mEventHandlerLinker;
}
eventProcessed |= roundEventProcessed;
} else {
handleNextRound = false;
}
}
return eventProcessed;
}
bool CTaskProcessorThreadBase::processTask(CTask* task) {
mLastProcessedTask = task;
task->clearNext();
task->getTaskStatus()->setTaskPROCESSINGState();
bool handleComp = mTaskHandleAlgo->handleTask(mTaskProcessorContext,task);
return handleComp;
}
}; // end namespace Scheduler
}; // end namespace Konclude