/*
* 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 "CSingleThreadTaskProcessorUnit.h"
namespace Konclude {
namespace Scheduler {
CSingleThreadTaskProcessorUnit::CSingleThreadTaskProcessorUnit(CTaskHandleAlgorithm* taskHandleAlgo, CConsiderateMemoryPoolProvider* memoryPoolProvider) : CThread("TaskProcessingUnitThread") {
mTaskProcessingQueue = nullptr;
mTaskCompletionQueue = nullptr;
mTaskStatusPropagator = nullptr;
mCallbackExecuter = nullptr;
mMemoryPoolProvider = memoryPoolProvider;
if (!mMemoryPoolProvider) {
mMemoryPoolProvider = new CNewAllocationMemoryPoolProvider();
}
mMemoryAllocator = new CTaskHandleLimitedReserveMemoryPoolAllocationManager(mMemoryPoolProvider,30000,30);
mTaskProcessorContext = new CTaskProcessorContextBase(this,mMemoryAllocator);
mTaskHandleAlgo = taskHandleAlgo;
mProcessingBlocked = true;
mEventHandler = new CQueuedLinkedEventHandler(this,this);
CXLinker* eventHandlerLinker = new CXLinker(mEventHandler,nullptr);
mEventHandlerLinker = eventHandlerLinker;
mProcessingStopped = false;
mStatComputionTime = 0;
mStatBlockingTime = 0;
mLastProcessingStartedTag = 0;
mLastProcessingStartRequestTag = 0;
mTaskProcessingCount = 0;
mTaskSchedulingCount = 0;
mStatRecievedScheduleTasks = 0;
mStatRemovedTasks = 0;
mEventSignalized = false;
mThreadBlocked = false;
mDebugLastProcessedTask = nullptr;
mDebugLastCompletedTask = nullptr;
mTaskSchedulingQueue = nullptr;
}
CSingleThreadTaskProcessorUnit::~CSingleThreadTaskProcessorUnit() {
}
cint64 CSingleThreadTaskProcessorUnit::countProcessingTasksMemoryPools() {
cint64 memoryPoolCount = 0;
CTask* taskProcessingQueueIt = mTaskProcessingQueue;
while (taskProcessingQueueIt) {
CMemoryPool* memoryPoolIt = taskProcessingQueueIt->getMemoryPools();
memoryPoolCount += memoryPoolIt->getCount();
taskProcessingQueueIt = taskProcessingQueueIt->getNext();
}
return memoryPoolCount;
}
cint64 CSingleThreadTaskProcessorUnit::countProcessedOpenTasksMemoryPools() {
cint64 memoryPoolCount = 0;
QSet taskSet;
QList taskList;
CTask* taskProcessingQueueIt = mTaskProcessingQueue;
while (taskProcessingQueueIt) {
if (taskProcessingQueueIt->getParentTask()) {
if (!taskSet.contains(taskProcessingQueueIt->getParentTask())) {
taskSet.insert(taskProcessingQueueIt->getParentTask());
taskList.append(taskProcessingQueueIt->getParentTask());
}
}
taskProcessingQueueIt = taskProcessingQueueIt->getNext();
}
while (!taskList.isEmpty()) {
CTask* task = taskList.takeFirst();
if (task->getParentTask()) {
if (!taskSet.contains(task->getParentTask())) {
taskSet.insert(task->getParentTask());
taskList.append(task->getParentTask());
}
}
CMemoryPool* memoryPoolIt = task->getMemoryPools();
memoryPoolCount += memoryPoolIt->getCount();
}
return memoryPoolCount;
}
cint64 CSingleThreadTaskProcessorUnit::closeOpenTasksMemoryPools() {
cint64 closedMemoryPoolCount = 0;
QSet taskSet;
QList taskList;
CTask* taskProcessingQueueIt = mTaskProcessingQueue;
while (taskProcessingQueueIt) {
if (!taskSet.contains(taskProcessingQueueIt)) {
taskSet.insert(taskProcessingQueueIt);
taskList.append(taskProcessingQueueIt);
}
taskProcessingQueueIt = taskProcessingQueueIt->getNext();
}
while (!taskList.isEmpty()) {
CTask* task = taskList.takeFirst();
CBooleanTaskResult* satResult = (CBooleanTaskResult*)task->getTaskResult();
if (satResult) {
satResult->installResult(false);
}
CCallbackData* callbackLinkerIt = task->getCallbackLinker();
while (callbackLinkerIt) {
CCallbackData* callback = callbackLinkerIt;
callbackLinkerIt = callbackLinkerIt->getNext();
if (mCallbackExecuter) {
mCallbackExecuter->executeCallback(task,callback);
INCTASKPROCESSINGSTAT(mStats.incStatisticCallbacksExecutedCount(1));
} else {
callback->doCallback();
}
}
if (task->getParentTask()) {
if (!taskSet.contains(task->getParentTask())) {
taskSet.insert(task->getParentTask());
taskList.append(task->getParentTask());
}
}
CMemoryPool* memoryPoolIt = task->getMemoryPools();
closedMemoryPoolCount += memoryPoolIt->getCount();
mMemoryAllocator->releaseMemoryPoolContainer(task);
}
mTaskProcessingQueue = 0;
mTaskCompletionQueue = 0;
return closedMemoryPoolCount;
}
CTaskHandleAlgorithm* CSingleThreadTaskProcessorUnit::getTaskHandleAlgorithm() {
return mTaskHandleAlgo;
}
CSingleThreadTaskProcessorUnit* CSingleThreadTaskProcessorUnit::installCallbackExecuter(CTaskCallbackExecuter* callbackExecuter) {
mCallbackExecuter = callbackExecuter;
return this;
}
CSingleThreadTaskProcessorUnit* CSingleThreadTaskProcessorUnit::installStatusPropagator(CTaskStatusPropagator* statusPropagator) {
mTaskStatusPropagator = statusPropagator;
return this;
}
cint64 CSingleThreadTaskProcessorUnit::getTaskProcessingCount() {
return mTaskProcessingCount + mTaskSchedulingCount;
}
bool CSingleThreadTaskProcessorUnit::canDispenseProcessingTasks() {
return false;
}
bool CSingleThreadTaskProcessorUnit::requiresProcessingTasks() {
return false;
}
bool CSingleThreadTaskProcessorUnit::requiresSchedulingTasks() {
return false;
}
cint64 CSingleThreadTaskProcessorUnit::countDispensableProcessingTasks() {
return 0;
}
cint64 CSingleThreadTaskProcessorUnit::getRecievedTasks() {
return 0;
}
cint64 CSingleThreadTaskProcessorUnit::countScheduleableProcessingTasks() {
return 0;
}
bool CSingleThreadTaskProcessorUnit::requiresTaskDispenseNotification(cint64 &updateDispenseNotificationTag) {
return false;
}
CTaskProcessingStatistics* CSingleThreadTaskProcessorUnit::getTaskProcessingStatistics() {
return &mStats;
}
cint64 CSingleThreadTaskProcessorUnit::getStatisticBlockingTime() {
cint64 blockTime = mStatBlockingTime;
#ifdef KONCLUDE_SCHEDULER_TASK_THREADS_TIME_STATISTICS
if (mThreadBlocked) {
blockTime += mBlockingTimer.elapsed();
}
#endif
return blockTime;
}
cint64 CSingleThreadTaskProcessorUnit::getStatisticComputionTime() {
cint64 compTime = mStatComputionTime;
#ifdef KONCLUDE_SCHEDULER_TASK_THREADS_TIME_STATISTICS
if (!mThreadBlocked) {
compTime += mComputionTimer.elapsed();
}
#endif
return compTime;
}
CEventHandler* CSingleThreadTaskProcessorUnit::getEventHandler() {
return mEventHandler;
}
CTaskEventHandlerBasedProcessor* CSingleThreadTaskProcessorUnit::installScheduler(CTaskEventHandlerBasedScheduler* scheduler) {
return this;
}
CTaskSchedulerCommunicator* CSingleThreadTaskProcessorUnit::createSchedulerProcessorCommunication(CTaskEventHandlerBasedProcessor* taskProcessor) {
return nullptr;
}
CTaskReserveQueueConsumer* CSingleThreadTaskProcessorUnit::createTaskReserveQueueConsumer(CTaskEventHandlerBasedProcessor* taskProcessor) {
return nullptr;
}
CSingleThreadTaskProcessorUnit* CSingleThreadTaskProcessorUnit::startProcessing() {
if (!isRunning()) {
startThread();
postEvent(new Concurrent::Events::CHandleEventsEvent());
}
return this;
}
CSingleThreadTaskProcessorUnit* CSingleThreadTaskProcessorUnit::stopProcessing() {
mProcessingStopped = true;
return this;
}
CThreadActivator* CSingleThreadTaskProcessorUnit::signalizeEvent() {
mEventSignalized = true;
if (mProcessingBlocked) {
// reactivate processing
if (mLastProcessingStartedTag == mLastProcessingStartRequestTag) {
++mLastProcessingStartRequestTag;
mProcessingWakeUpSemaphore.release();
}
}
return this;
}
bool CSingleThreadTaskProcessorUnit::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 CSingleThreadTaskProcessorUnit::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.acquire(1);
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();
cint64 taskDepth = processingTask->getTaskDepth();
//cint64 memoryPoolCount1 = countProcessingTasksMemoryPools();
//cint64 memoryPoolCount2 = countProcessedOpenTasksMemoryPools();
bool continueProcessing = processTask(processingTask);
if (continueProcessing) {
processingTask->getTaskStatus()->setTaskQUEUEDState();
if (mTaskProcessingQueue) {
mTaskProcessingQueue = mTaskProcessingQueue->insertNextSorted(processingTask);
} else {
mTaskProcessingQueue = processingTask;
}
} else {
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksProcessedDepthCount(taskDepth,1));
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksProcessedCount(1));
--mTaskProcessingCount;
++mStatRemovedTasks;
}
//if (mStatRemovedTasks > 100000) {
// closeOpenTasksMemoryPools();
//}
}
if (!mTaskProcessingQueue && mTaskSchedulingQueue) {
CTask* nextTask = mTaskSchedulingQueue;
mTaskSchedulingQueue = mTaskSchedulingQueue->getNext();
nextTask->clearNext();
--mTaskSchedulingCount;
addProcessingTask(nextTask);
}
if (!mTaskProcessingQueue) {
while (mEventSignalized || !eventSafeguardProcessed) {
bool eventsProcessed = handleEvents();
if (eventsProcessed) {
eventSafeguardProcessed = false;
mProcessingBlocked = false;
} else if (!mProcessingBlocked) {
mProcessingBlocked = true;
} else if (!eventSafeguardProcessed) {
eventSafeguardProcessed = true;
}
}
}
}
return true;
}
bool CSingleThreadTaskProcessorUnit::processEvent(CEvent *event, CContext* handlerContext) {
cint64 eventID = event->getEventTypeID();
if (eventID == CSendTaskProcessEvent::EVENTTYPEID) {
CTask* task = ((CSendTaskProcessEvent*)event)->getTask();
addProcessingTask(task);
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CSendTaskScheduleEvent::EVENTTYPEID) {
++mStatRecievedScheduleTasks;
CTask* task = ((CSendTaskScheduleEvent*)event)->getTask();
if (!mTaskProcessingQueue) {
addProcessingTask(task);
} else {
++mTaskSchedulingCount;
if (mTaskSchedulingQueue) {
mTaskSchedulingQueue = mTaskSchedulingQueue->append(task);
} else {
mTaskSchedulingQueue = task;
}
}
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CRequestProcessTaskEvent::EVENTTYPEID) {
// not supported
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CResponseScheduleTaskEvent::EVENTTYPEID) {
// not supported
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CSendTaskCompleteEvent::EVENTTYPEID) {
CTask* task = ((CSendTaskCompleteEvent*)event)->getTask();
completeTask(task);
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CTaskAdditionalAllocationEvent::EVENTTYPEID) {
CTaskAdditionalAllocationEvent* taskAddAllocEvent = (CTaskAdditionalAllocationEvent*)event;
CTask* task = taskAddAllocEvent->getTask();
CMemoryPool* addMemoryPools = taskAddAllocEvent->getAdditionalAllocatedMemoryPools();
task->appendMemoryPool(addMemoryPools);
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CRequestScheduleTaskEvent::EVENTTYPEID) {
// this unit is also the scheduler
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else {
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
}
return false;
}
CTaskProcessorCommunicator* CSingleThreadTaskProcessorUnit::communicateTaskComplete(CTask* task) {
task->getTaskStatus()->setTaskFINISHEDState();
completeTask(task);
return this;
}
CTaskProcessorCommunicator* CSingleThreadTaskProcessorUnit::communicateTaskError(CTask* task) {
task->getTaskStatus()->setTaskFINISHEDState();
completeTask(task);
return this;
}
bool CSingleThreadTaskProcessorUnit::addProcessingTask(CTask* task) {
CTask* newTask = task;
CTask* newTaskIt = newTask;
cint64 taskCount = 0;
while (newTaskIt) {
newTaskIt->getTaskStatus()->setTaskQUEUEDState();
newTaskIt = newTaskIt->getNext();
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksAddedCount(1));
++taskCount;
}
mTaskProcessingCount += taskCount;
if (!mTaskProcessingQueue) {
mTaskProcessingQueue = newTask;
newTask = newTask->getNext();
mTaskProcessingQueue->clearNext();
}
if (newTask) {
mTaskProcessingQueue = mTaskProcessingQueue->insertNextSorted(newTask);
}
return task != nullptr;
}
CTaskProcessorCommunicator* CSingleThreadTaskProcessorUnit::communicateTaskCreation(CTask* newTask) {
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCreatedCount(newTask->getCount()));
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCreatedDepthCount(newTask->getTaskDepth(),newTask->getCount()));
addProcessingTask(newTask);
return this;
}
CTaskProcessorCommunicator* CSingleThreadTaskProcessorUnit::communicateTaskAdditionalAllocation(CTask* task, CMemoryPool* additionalAllocatedMemoryPool) {
task->appendMemoryPool(additionalAllocatedMemoryPool);
return this;
}
bool CSingleThreadTaskProcessorUnit::verifyContinueTaskProcessing(CTask* task) {
if (mEventSignalized) {
return false;
}
if (!task->getTaskStatus()->isProcessable()) {
return false;
}
if (mTaskProcessingQueue && mTaskProcessingQueue->getTaskPriority() > task->getTaskPriority()) {
return false;
}
return true;
}
bool CSingleThreadTaskProcessorUnit::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;
}
cint64 CSingleThreadTaskProcessorUnit::completeTask(CTask* task) {
cint64 completedCount = 0;
mTaskCompletionQueue = task->getLastListLink()->setNext(mTaskCompletionQueue);
while (mTaskCompletionQueue) {
CTask* completionTask = mTaskCompletionQueue;
mTaskCompletionQueue = mTaskCompletionQueue->getNext();
if (completionTask && !completionTask->hasActiveReferencedTask()) {
mDebugLastCompletedTask = completionTask;
CTask* parentTask = completionTask->getParentTask();
bool upPropagation = false;
if (mTaskStatusPropagator && mTaskStatusPropagator->completeTaskStatus(completionTask,upPropagation)) {
if (parentTask && upPropagation) {
updateTaskStatus(parentTask);
}
}
completionTask->completeTask();
completionTask->getTaskStatus()->setTaskCOMPLETEDState();
bool memoryReleaseable = completionTask->getTaskStatus()->isMemoryReleaseable();
if (parentTask) {
parentTask->decActiveReferenceCount();
if (!parentTask->hasActiveReferencedTask()) {
mTaskCompletionQueue = parentTask->setNext(mTaskCompletionQueue);
}
}
if (completionTask) {
// callbacks
CCallbackData* callbackLinkerIt = completionTask->getCallbackLinker();
while (callbackLinkerIt) {
CCallbackData* callback = callbackLinkerIt;
callbackLinkerIt = callbackLinkerIt->getNext();
if (mCallbackExecuter) {
mCallbackExecuter->executeCallback(completionTask,callback);
INCTASKPROCESSINGSTAT(mStats.incStatisticCallbacksExecutedCount(1));
} else {
callback->doCallback();
}
}
}
if (memoryReleaseable) {
for (CDeletionLinker* deletionLinkerIt = completionTask->takeDeletionLinker(); deletionLinkerIt; deletionLinkerIt = deletionLinkerIt->getNext()) {
deletionLinkerIt->deleteObject();
}
mMemoryAllocator->releaseMemoryPoolContainer(completionTask);
}
completedCount++;
}
}
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCompletedCount(completedCount));
return completedCount;
}
bool CSingleThreadTaskProcessorUnit::processTask(CTask* task) {
mDebugLastProcessedTask = task;
task->clearNext();
task->getTaskStatus()->setTaskPROCESSINGState();
return mTaskHandleAlgo->handleTask(mTaskProcessorContext,task);
}
CTaskProcessorCommunicator* CSingleThreadTaskProcessorUnit::communicateTaskRelevant(CTask* task) {
// nothing to do for single processor unit
return this;
}
CTaskProcessorCommunicator* CSingleThreadTaskProcessorUnit::communicateTaskStatusUpdate(CTask* task) {
updateTaskStatus(task);
return this;
}
bool CSingleThreadTaskProcessorUnit::updateTaskStatusDown(CTask* task, cint64 depth) {
if (depth < 1000) {
bool downProp = false;
bool upProp = false;
CTask* updateTask = task;
updateTask->setTaskID(-1);
if (mTaskStatusPropagator && mTaskStatusPropagator->updateTaskStatus(updateTask, downProp, upProp)) {
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksUpdatedCount(1));
if (downProp) {
CXNegLinker* refTaskIt = updateTask->getReferencedTaskLinker();
while (refTaskIt) {
if (refTaskIt->isNegated()) {
// task still exists, update task status
// TODO: check better not recursive?
CTask* refTask = refTaskIt->getData();
updateTaskStatusDown(refTask, depth + 1);
}
refTaskIt = refTaskIt->getNext();
}
}
}
} else {
QList updateTaskList;
updateTaskList.append(task);
while (!updateTaskList.isEmpty()) {
bool downProp = false;
bool upProp = false;
CTask* updateTask = updateTaskList.takeFirst();
if (mTaskStatusPropagator && mTaskStatusPropagator->updateTaskStatus(updateTask, downProp, upProp)) {
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksUpdatedCount(1));
if (downProp) {
CXNegLinker* refTaskIt = updateTask->getReferencedTaskLinker();
while (refTaskIt) {
if (refTaskIt->isNegated()) {
// task still exists, update task status
// TODO: check better not recursive?
CTask* refTask = refTaskIt->getData();
updateTaskList.append(refTask);
}
refTaskIt = refTaskIt->getNext();
}
}
}
}
}
return true;
}
bool CSingleThreadTaskProcessorUnit::updateTaskStatus(CTask* task) {
CTask* updateTask = task;
bool downProp = false;
bool upProp = false;
while (updateTask) {
if (mTaskStatusPropagator && mTaskStatusPropagator->updateTaskStatus(updateTask,downProp,upProp)) {
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksUpdatedCount(1));
if (downProp) {
CXNegLinker* refTaskIt = updateTask->getReferencedTaskLinker();
while (refTaskIt) {
if (refTaskIt->isNegated()) {
// task still exists, update task status
// TODO: check better not recursive?
CTask* refTask = refTaskIt->getData();
updateTaskStatusDown(refTask, 0);
}
refTaskIt = refTaskIt->getNext();
}
}
if (upProp) {
// all parent task are owned by the completer
//CTask* parentTask = updateTask->getParentTask();
//if (parentTask) {
// updateTaskStatus(parentTask);
//}
updateTask = updateTask->getParentTask();
} else {
updateTask = nullptr;
}
} else {
updateTask = nullptr;
}
}
return true;
}
}; // end namespace Scheduler
}; // end namespace Konclude