/*
* 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 "CTaskProcessorCompletorThread.h"
namespace Konclude {
namespace Scheduler {
CTaskProcessorCompletorThread::CTaskProcessorCompletorThread(CTaskHandleAlgorithm* taskHandleAlgo, CConsiderateMemoryPoolProvider* memoryPoolProvider) : CTaskProcessorThreadBase(taskHandleAlgo,"TaskProcesserCompletorThread"),CConcreteMemoryPoolDistributor(nullptr) {
mMemoryPoolReleaser = new CDirectDistributionMemoryPoolReleaser(this);
mMemoryPoolProvider = memoryPoolProvider;
if (!mMemoryPoolProvider) {
//mMemoryPoolProvider = CConcreteMemoryPoolDistributor::createDistributionMemoryPoolProvider(mMemoryPoolReleaser);
mMemoryPoolProvider = new CNewAllocationMemoryPoolProvider();
}
mMemoryAllocator = new CTaskHandleLimitedReserveMemoryPoolAllocationManager(mMemoryPoolProvider,80000,30);
mTaskProcessorContext = new CTaskProcessorContextBase(this,mMemoryAllocator);
mSchedulerCommunicator = nullptr;
mDispenseNotificationTag = 0;
}
CTaskProcessorCompletorThread::~CTaskProcessorCompletorThread() {
}
CTaskEventHandlerBasedProcessor* CTaskProcessorCompletorThread::installScheduler(CTaskEventHandlerBasedScheduler* scheduler) {
mTaskReserveQueueConsumer = scheduler->createTaskReserveQueueConsumer(this);
CTaskSchedulerCommunicator* schedulerCommunicator = scheduler->createSchedulerProcessorCommunication(this);
installSchedulerCommunicator(schedulerCommunicator);
return this;
}
CTaskProcessorCompletorThread* CTaskProcessorCompletorThread::installSchedulerCommunicator(CTaskSchedulerCommunicator* schedulerCommunicator) {
mSchedulerCommunicator = schedulerCommunicator;
mSchedulerCommunicator->communicateRequestProcessTask(mMemoryAllocator);
return this;
}
CDistributionMemoryPoolProvider* CTaskProcessorCompletorThread::createDistributionMemoryPoolProvider(CDistributionMemoryPoolReleaser* distributionMemoryReleaser) {
return CConcreteMemoryPoolDistributor::createDistributionMemoryPoolProvider(distributionMemoryReleaser);
}
CConcreteMemoryPoolDistributor* CTaskProcessorCompletorThread::distributeMemoryPools(CMemoryPool* memoryPools) {
return CConcreteMemoryPoolDistributor::distributeMemoryPools(memoryPools);
}
bool CTaskProcessorCompletorThread::processEvent(CEvent *event, CContext* handlerContext) {
mLastProcessedEvent = event;
cint64 eventID = event->getEventTypeID();
if (eventID == CTaskStatusUpdatedEvent::EVENTTYPEID) {
CTaskStatusUpdatedEvent* tsue = (CTaskStatusUpdatedEvent*)event;
CTask* parentTask = tsue->getParentTask();
CTask* updatedTask = tsue->getUpdatedTask();
bool updateSuccess = tsue->getUpdateSuccess();
processTaskStatusUpdated(parentTask,updatedTask,updateSuccess);
return true;
} else if (eventID == CAlignedUpdateTaskStatusEvent::EVENTTYPEID) {
CAlignedUpdateTaskStatusEvent* autse = (CAlignedUpdateTaskStatusEvent*)event;
CTask* updateTask = autse->getUpdateTask();
processUpdateTaskStatus(updateTask);
return true;
} else if (CTaskProcessorThreadBase::processEvent(event,handlerContext)) {
return true;
} else {
// not supported event
}
return false;
}
bool CTaskProcessorCompletorThread::processDispenseNotification() {
if (canDispenseProcessingTasks() && mSchedulerCommunicator->requiresTaskDispenseNotification(mDispenseNotificationTag)) {
mSchedulerCommunicator->communicateTaskDispenseNotification(mMemoryAllocator);
}
return true;
}
bool CTaskProcessorCompletorThread::processRequestProcessTask() {
mSchedulerCommunicator->communicateRequestProcessTask(mMemoryAllocator);
return true;
}
bool CTaskProcessorCompletorThread::processCriticalScheduleTask() {
mSchedulerCommunicator->communicateCriticalScheduleTask(mMemoryAllocator);
return true;
}
bool CTaskProcessorCompletorThread::processCompleteTask(CTask* task) {
cint64 completedCount = 0;
mTaskCompletionQueue = task->getLastListLink()->setNext(mTaskCompletionQueue);
while (mTaskCompletionQueue) {
CTask* completionTask = mTaskCompletionQueue;
mTaskCompletionQueue = mTaskCompletionQueue->getNext();
if (completionTask) {
if (completionTask->hasDependedStatusUpdates()) {
completionTask->setCompletionRequested(true);
} else if (!completionTask->hasActiveReferencedTask()) {
CTask* parentTask = completionTask->getParentTask();
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);
INCTASKPROCESSINGSTAT(mStats.incStatisticCallbacksExecutedCount(1));
} 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++;
}
}
}
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCompletedCount(completedCount));
return true;
}
bool CTaskProcessorCompletorThread::processAdditionalTaskAllocation(CTask* task, CMemoryPool* memoryPool) {
task->appendMemoryPool(memoryPool);
return true;
}
bool CTaskProcessorCompletorThread::processResponseScheduleTask(CTask* task, CTaskScheduleItem* taskScheduleItem, bool schedulingTask) {
mSchedulerCommunicator->communicateResponseScheduleTask(taskScheduleItem,task,schedulingTask,mMemoryAllocator);
return true;
}
bool CTaskProcessorCompletorThread::processTaskStatusUpdated(CTask* parentTask, CTask* updatedTask, bool updateSuccess) {
bool needsMayTaskCompletion = false;
if (updateSuccess) {
parentTask->decDependedStatusUpdatesCount();
needsMayTaskCompletion = true;
} else {
// task is already completed or is now owned by completer
// check whether task is completed
bool taskCompleted = false;
CXNegLinker* refTaskLinkerIt = parentTask->getReferencedTaskLinker();
while (refTaskLinkerIt) {
CTask* refTask = refTaskLinkerIt->getData();
if (refTask == updatedTask) {
if (!refTaskLinkerIt->isNegated()) {
taskCompleted = true;
}
break;
}
refTaskLinkerIt = refTaskLinkerIt->getNext();
}
if (taskCompleted) {
parentTask->decDependedStatusUpdatesCount();
needsMayTaskCompletion = true;
} else {
if (parentTask->hasTaskOwner(this) || !parentTask->hasTaskOwner()) {
processUpdateTaskStatus(parentTask,updatedTask);
needsMayTaskCompletion = true;
} else {
mSchedulerCommunicator->communicateScheduleUpdateTaskStatus(parentTask,updatedTask,mMemoryAllocator);
}
}
}
if (needsMayTaskCompletion) {
if (parentTask->isCompletionRequested()) {
if (!parentTask->hasDependedStatusUpdates()) {
processCompleteTask(parentTask);
}
}
}
return true;
}
bool CTaskProcessorCompletorThread::processUpdateTaskStatus(CTask* parentTask, CTask* updateTask) {
if (!parentTask || parentTask->hasTaskOwner(this) || !parentTask->hasTaskOwner()) {
// local task status update
processUpdateTaskStatus(updateTask);
processTaskStatusUpdated(parentTask,updateTask,true);
} else {
processTaskStatusUpdated(parentTask,updateTask,false);
}
return true;
}
bool CTaskProcessorCompletorThread::processUpdateTaskStatus(CTask* task) {
CTask* updateTask = task;
bool downProp = false;
bool upProp = false;
CTaskOwner* taskOwner = updateTask->getTaskOwner();
if (mTaskStatusPropagator && mTaskStatusPropagator->updateTaskStatus(updateTask,downProp,upProp)) {
if (downProp) {
if (taskOwner == nullptr || taskOwner == this) {
// update task status direct
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();
}
} else {
// signalize task status update per event to other processing units
CXNegLinker* refTaskIt = updateTask->getReferencedTaskLinker();
while (refTaskIt) {
if (refTaskIt->isNegated()) {
// task still exists, update task status with event to corresponding processor unit
CTask* refTask = refTaskIt->getData();
updateTask->incDependedStatusUpdatesCount();
mSchedulerCommunicator->communicateScheduleUpdateTaskStatus(updateTask,refTask,mMemoryAllocator);
}
refTaskIt = refTaskIt->getNext();
}
}
}
if (upProp) {
// all parent task are owned by the completer
CTask* parentTask = updateTask->getParentTask();
if (parentTask) {
processUpdateTaskStatus(parentTask);
}
}
}
return true;
}
}; // end namespace Scheduler
}; // end namespace Konclude