/* * 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 "CTaskProcessorThread.h" namespace Konclude { namespace Scheduler { CTaskProcessorThread::CTaskProcessorThread(CTaskHandleAlgorithm* taskHandleAlgo, CTaskEventHandlerBasedDistributionCompletor* distributorCompletor, CConsiderateMemoryPoolProvider* memoryPoolProvider) : CTaskProcessorThreadBase(taskHandleAlgo,"TaskProcesserSchedulerThread") { mDistributorCompletorCommunicator = new CTaskDistributionCompletorCommunicator(distributorCompletor,this); mMemoryPoolReleaser = new CEventDistributionMemoryPoolReleaser(mDistributorCompletorCommunicator); mMemoryPoolProvider = memoryPoolProvider; if (!mMemoryPoolProvider) { //mMemoryPoolProvider = distributorCompletor->createDistributionMemoryPoolProvider(mMemoryPoolReleaser); mMemoryPoolProvider = new CNewAllocationMemoryPoolProvider(); } mMemoryAllocator = new CTaskHandleLimitedReserveMemoryPoolAllocationManager(mMemoryPoolProvider,80000,30); mTaskProcessorContext = new CTaskProcessorContextBase(this,mMemoryAllocator); mDispenseNotificationTag = 0; mSchedulerCommunicator = nullptr; } CTaskProcessorThread::~CTaskProcessorThread() { } CTaskEventHandlerBasedProcessor* CTaskProcessorThread::installScheduler(CTaskEventHandlerBasedScheduler* scheduler) { mTaskReserveQueueConsumer = scheduler->createTaskReserveQueueConsumer(this); CTaskSchedulerCommunicator* schedulerCommunicator = scheduler->createSchedulerProcessorCommunication(this); installSchedulerCommunicator(schedulerCommunicator); return this; } CTaskProcessorThread* CTaskProcessorThread::installSchedulerCommunicator(CTaskSchedulerCommunicator* schedulerCommunicator) { mSchedulerCommunicator = schedulerCommunicator; mSchedulerCommunicator->communicateRequestProcessTask(mMemoryAllocator); return this; } bool CTaskProcessorThread::processEvent(CEvent *event, CContext* handlerContext) { cint64 eventID = event->getEventTypeID(); if (CTaskProcessorThreadBase::processEvent(event,handlerContext)) { return true; } else { // not supported } return false; } bool CTaskProcessorThread::processDispenseNotification() { bool schedulerReqDis = mSchedulerCommunicator->requiresTaskDispenseNotification(mDispenseNotificationTag); organizeDispenseTasks(schedulerReqDis); if (canDispenseProcessingTasks() && schedulerReqDis) { mSchedulerCommunicator->communicateTaskDispenseNotification(mMemoryAllocator); } return true; } bool CTaskProcessorThread::processRequestProcessTask() { mSchedulerCommunicator->communicateRequestProcessTask(mMemoryAllocator); return true; } bool CTaskProcessorThread::processCriticalScheduleTask() { mSchedulerCommunicator->communicateCriticalScheduleTask(mMemoryAllocator); return true; } bool CTaskProcessorThread::processCompleteTask(CTask* task) { // try locale to complete task cint64 completedCount = 0; mTaskCompletionQueue = task->getLastListLink()->setNext(mTaskCompletionQueue); while (mTaskCompletionQueue) { CTask* completionTask = mTaskCompletionQueue; mTaskCompletionQueue = mTaskCompletionQueue->getNext(); if (completionTask && !completionTask->hasActiveReferencedTask()) { CTask* parentTask = completionTask->getParentTask(); if (!parentTask || parentTask->hasNoTaskOwnerAndNoParentTask() || parentTask->hasTaskOwner(this)) { // locale task completion bool upPropagation = false; if (mTaskStatusPropagator && mTaskStatusPropagator->completeTaskStatus(completionTask,upPropagation)) { if (parentTask && upPropagation) { processUpdateTaskStatus(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); } else { callback->doCallback(); } } } #ifndef KONCLUDE_SCHEDULER_DEBUG_TASK_MEMORY_RELEASE if (memoryReleaseable) { for (CDeletionLinker* deletionLinkerIt = completionTask->takeDeletionLinker(); deletionLinkerIt; deletionLinkerIt = deletionLinkerIt->getNext()) { deletionLinkerIt->deleteObject(); } mMemoryAllocator->releaseMemoryPoolContainer(completionTask); } #endif completedCount++; } else { // task completion by completer mDistributorCompletorCommunicator->communicateTaskComplete(completionTask,mMemoryAllocator); } } } INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCompletedCount(completedCount)); return true; } bool CTaskProcessorThread::processAdditionalTaskAllocation(CTask* task, CMemoryPool* memoryPool) { CTask* parentTask = task->getParentTask(); if (!parentTask || parentTask->hasNoTaskOwnerAndNoParentTask() || parentTask->hasTaskOwner(this)) { task->appendMemoryPool(memoryPool); } else { mDistributorCompletorCommunicator->communicateAdditionalAllocationTask(task,memoryPool,mMemoryAllocator); } return true; } bool CTaskProcessorThread::processResponseScheduleTask(CTask* task, CTaskScheduleItem* taskScheduleItem, bool schedulingTask) { mSchedulerCommunicator->communicateResponseScheduleTask(taskScheduleItem,task,schedulingTask,mMemoryAllocator); return true; } bool CTaskProcessorThread::processUpdateTaskStatus(CTask* updateTask) { CTask* parentTask = updateTask->getParentTask(); if (!parentTask || parentTask->hasNoTaskOwnerAndNoParentTask() || parentTask->hasTaskOwner(this)) { // update status local bool downProp = false; bool upProp = false; if (mTaskStatusPropagator && mTaskStatusPropagator->updateTaskStatus(updateTask,downProp,upProp)) { if (downProp) { // update task status local CXNegLinker* refTaskIt = updateTask->getReferencedTaskLinker(); while (refTaskIt) { if (refTaskIt->isNegated()) { // task still exists, update task status // TODO: check better not recursive? CTask* refTask = refTaskIt->getData(); processUpdateTaskStatus(refTask); } refTaskIt = refTaskIt->getNext(); } } if (upProp && parentTask) { processUpdateTaskStatus(parentTask); } } } else { mDistributorCompletorCommunicator->communicateAlignedUpdateTaskStatus(updateTask,mMemoryAllocator); } return true; } bool CTaskProcessorThread::processUpdateTaskStatus(CTask* parentTask, CTask* updateTask) { if (parentTask->hasNoTaskOwnerAndNoParentTask() || parentTask->hasTaskOwner(this)) { // local task status update // check whether task is completed bool taskCompleted = false; CXNegLinker* refTaskLinkerIt = parentTask->getReferencedTaskLinker(); while (refTaskLinkerIt) { CTask* refTask = refTaskLinkerIt->getData(); if (refTask == updateTask) { if (!refTaskLinkerIt->isNegated()) { taskCompleted = true; } break; } refTaskLinkerIt = refTaskLinkerIt->getNext(); } if (!taskCompleted) { processUpdateTaskStatus(updateTask); } mDistributorCompletorCommunicator->communicateTaskStatusUpdated(parentTask,updateTask,true,mMemoryAllocator); } else { mDistributorCompletorCommunicator->communicateTaskStatusUpdated(parentTask,updateTask,false,mMemoryAllocator); } return true; } }; // end namespace Scheduler }; // end namespace Konclude