/*
* 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 "CTaskProcessorSchedulerThread.h"
namespace Konclude {
namespace Scheduler {
CTaskProcessorSchedulerThread::CTaskProcessorSchedulerThread(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);
mFreeSchedulerItemLinker = nullptr;
mWaitingSchedulerItemLinker = nullptr;
mSchedulerCommunicatorLinker = nullptr;
mRequestingTaskCount = 0;
mDeliveringWaitingCount = 0;
mRequiresTaskDispenseNotification = false;
mSchedulerDispenseNotificationTag = 0;
mDispenseNotificationTag = 0;
mProcessorWithCriticalScheduleTask = false;
mSchedulerCommunicator = nullptr;
mLastScheduledTask = nullptr;
mTaskReserveQueue = new CTaskReserveArrayQueue(10000);
mTaskReserveQueueController = nullptr;
//mTaskReserveQueue = new CTaskReserveMultiArrayQueue(10000);
//mTaskReserveQueueController = new CTaskReserveMultiArrayQueueAdderController(mTaskReserveQueue);
}
CTaskProcessorSchedulerThread::~CTaskProcessorSchedulerThread() {
}
bool CTaskProcessorSchedulerThread::requiresSchedulingTasks() {
return false;
}
CTaskReserveQueue* CTaskProcessorSchedulerThread::getTaskReserveQueue() {
return mTaskReserveQueue;
}
CTaskReserveQueueAdder* CTaskProcessorSchedulerThread::createTaskReserveQueueAdder() {
if (mTaskReserveQueueController) {
return mTaskReserveQueueController->createTaskReserveQueueAdder();
} else {
return nullptr;
}
}
bool CTaskProcessorSchedulerThread::requiresTaskDispenseNotification(cint64 &updateDispenseNotificationTag) {
bool requiresNotification = updateDispenseNotificationTag != mSchedulerDispenseNotificationTag;
updateDispenseNotificationTag = mSchedulerDispenseNotificationTag;
return requiresNotification;
}
CTaskSchedulerCommunicator* CTaskProcessorSchedulerThread::createSchedulerProcessorCommunication(CTaskEventHandlerBasedProcessor* taskProcessor) {
CConcreteTaskSchedulerCommunicator* taskSchedulerCommunicator = new CConcreteTaskSchedulerCommunicator(this,taskProcessor);
mCreateCommunicatorSyncMutex.lock();
mSchedulerCommunicatorLinker = new CXLinker(taskSchedulerCommunicator,mSchedulerCommunicatorLinker);
mCreateCommunicatorSyncMutex.unlock();
return taskSchedulerCommunicator;
}
CTaskReserveQueueConsumer* CTaskProcessorSchedulerThread::createTaskReserveQueueConsumer(CTaskEventHandlerBasedProcessor* taskProcessor) {
CTaskReserveQueueConsumer* consumer = nullptr;
if (mConfUseReserveTasksQueue && mTaskReserveQueue) {
consumer = mTaskReserveQueue->createTaskReserveQueueConsumer();
}
return consumer;
}
CTaskEventHandlerBasedProcessor* CTaskProcessorSchedulerThread::installScheduler(CTaskEventHandlerBasedScheduler* scheduler) {
mTaskReserveQueueConsumer = scheduler->createTaskReserveQueueConsumer(this);
CTaskSchedulerCommunicator* schedulerCommunicator = scheduler->createSchedulerProcessorCommunication(this);
installSchedulerCommunicator(schedulerCommunicator);
return this;
}
CTaskProcessorSchedulerThread* CTaskProcessorSchedulerThread::installSchedulerCommunicator(CTaskSchedulerCommunicator* schedulerCommunicator) {
mSchedulerCommunicator = schedulerCommunicator;
processSchedulerRequestProcessTask(mSchedulerCommunicator);
return this;
}
bool CTaskProcessorSchedulerThread::processEvent(CEvent *event, CContext* handlerContext) {
mLastProcessedEvent = event;
cint64 eventID = event->getEventTypeID();
if (eventID == CSendTaskScheduleEvent::EVENTTYPEID) {
CTask* taskIt = ((CSendTaskScheduleEvent*)event)->getTask();
while (taskIt) {
CTask* task = taskIt;
taskIt = taskIt->getNext();
task->clearNext();
processSchedulerScheduleTask(task,true);
}
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CRequestProcessTaskEvent::EVENTTYPEID) {
CRequestProcessTaskEvent* reqEvent = (CRequestProcessTaskEvent*)event;
processSchedulerRequestProcessTask(reqEvent->getCommunicator());
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CTaskDispenseNotificationEvent::EVENTTYPEID) {
CTaskDispenseNotificationEvent* disNotEvent = (CTaskDispenseNotificationEvent*)event;
processSchedulerDispenseNotification(disNotEvent->getCommunicator());
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CCriticalScheduleTaskEvent::EVENTTYPEID) {
CCriticalScheduleTaskEvent* criticalScheduleTasksEvent = (CCriticalScheduleTaskEvent*)event;
processSchedulingScheduleTasks();
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (eventID == CResponseScheduleTaskEvent::EVENTTYPEID) {
CResponseScheduleTaskEvent* resEvent = (CResponseScheduleTaskEvent*)event;
processSchedulerResponseScheduleTask(resEvent->getTask(),resEvent->getCommunicator(),resEvent->getTaskScheduleItem(),resEvent->isSchedulingTask());
mMemoryAllocator->releaseMemoryPoolContainer(event);
return true;
} else if (CTaskProcessorThreadBase::processEvent(event,handlerContext)) {
return true;
} else {
// not supported
}
return false;
}
bool CTaskProcessorSchedulerThread::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 CTaskProcessorSchedulerThread::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 {
// delegate task update to processor unit
CTaskOwner* taskOwner = parentTask->getTaskOwner();
bool scheduled = false;
CXLinker* commLinkIt = mSchedulerCommunicatorLinker;
while (commLinkIt) {
CConcreteTaskSchedulerCommunicator* communicator = commLinkIt->getData();
if (communicator->hasTaskOwner(taskOwner)) {
communicator->communicateUpdateTaskStatus(parentTask,updateTask,mMemoryAllocator);
scheduled = true;
break;
}
commLinkIt = commLinkIt->getNext();
}
if (!scheduled) {
mDistributorCompletorCommunicator->communicateTaskStatusUpdated(parentTask,updateTask,false,mMemoryAllocator);
}
}
return true;
}
bool CTaskProcessorSchedulerThread::processSchedulerRequestProcessTask(CTaskSchedulerCommunicator* communicator) {
if (!mFreeSchedulerItemLinker) {
mFreeSchedulerItemLinker = new CConcreteTaskScheduleItem();
}
CConcreteTaskScheduleItem* tmpTaskScheduleItem = mFreeSchedulerItemLinker;
mFreeSchedulerItemLinker = mFreeSchedulerItemLinker->getNext();
tmpTaskScheduleItem->initTaskScheduleItem((CConcreteTaskSchedulerCommunicator*)communicator,mWaitingSchedulerItemLinker);
mWaitingSchedulerItemLinker = tmpTaskScheduleItem;
mDeliveringWaitingCount++;
processTaskScheduling();
return true;
}
bool CTaskProcessorSchedulerThread::processSchedulerCriticalScheduleTask(CTaskSchedulerCommunicator* communicator) {
mProcessorWithCriticalScheduleTask = true;
processTaskScheduling();
return true;
}
bool CTaskProcessorSchedulerThread::processSchedulerResponseScheduleTask(CTask* task, CTaskSchedulerCommunicator* communicator, CTaskScheduleItem* taskScheduleItem, bool schedulingTask) {
CConcreteTaskSchedulerCommunicator* concreteCommunicator = (CConcreteTaskSchedulerCommunicator*)communicator;
concreteCommunicator->decRequestProcessingTask();
--mRequestingTaskCount;
processSchedulerScheduleTask(task,schedulingTask);
return true;
}
bool CTaskProcessorSchedulerThread::processTaskScheduling() {
bool requestingTasks = false;
bool canContinueRequestProcessTask = true;
bool canContinueRequestScheduleTask = true;
if (mConfUseReserveTasksQueue && mTaskReserveQueueConsumer && mWaitingSchedulerItemLinker) {
CTask* task = nullptr;
do {
task = mTaskReserveQueueConsumer->getTask();
processSchedulerScheduleTask(task,true);
} while (task && mWaitingSchedulerItemLinker);
}
while (canContinueRequestScheduleTask && mDeliveringWaitingCount > mRequestingTaskCount) {
canContinueRequestScheduleTask = false;
cint64 maxSchedTasks = 0;
CConcreteTaskSchedulerCommunicator* maxSchedComm = nullptr;
CXLinker* schedulerCommunicatorLinkerIt = mSchedulerCommunicatorLinker;
while (schedulerCommunicatorLinkerIt && mDeliveringWaitingCount > mRequestingTaskCount) {
CConcreteTaskSchedulerCommunicator* communicator = schedulerCommunicatorLinkerIt->getData();
cint64 schedTasks = communicator->getRequestUpdatedDispensableSchedulingTasksCount();
if (schedTasks > 0) {
if (!maxSchedComm || schedTasks > maxSchedTasks) {
maxSchedComm = communicator;
maxSchedTasks = schedTasks;
}
}
schedulerCommunicatorLinkerIt = schedulerCommunicatorLinkerIt->getNext();
}
if (maxSchedComm) {
maxSchedComm->communicateRequestScheduleTask(nullptr,mMemoryAllocator);
maxSchedComm->incRequestProcessingTask();
canContinueRequestScheduleTask = true;
++mRequestingTaskCount;
requestingTasks = true;
}
}
while (canContinueRequestProcessTask && mDeliveringWaitingCount > mRequestingTaskCount) {
canContinueRequestProcessTask = false;
CXLinker* schedulerCommunicatorLinkerIt = mSchedulerCommunicatorLinker;
while (schedulerCommunicatorLinkerIt && mDeliveringWaitingCount > mRequestingTaskCount) {
CConcreteTaskSchedulerCommunicator* communicator = schedulerCommunicatorLinkerIt->getData();
if (mConfProcessingTasksDistribution && communicator->getRequestUpdatedDispensableProcessingAndSchedulingTasksCount() > 1) {
communicator->communicateRequestScheduleTask(nullptr,mMemoryAllocator);
communicator->incRequestProcessingTask();
canContinueRequestProcessTask = true;
++mRequestingTaskCount;
requestingTasks = true;
}
schedulerCommunicatorLinkerIt = schedulerCommunicatorLinkerIt->getNext();
}
}
if (mDeliveringWaitingCount > mRequestingTaskCount) {
++mSchedulerDispenseNotificationTag;
mRequiresTaskDispenseNotification = true;
} else {
mRequiresTaskDispenseNotification = false;
}
return requestingTasks;
}
bool CTaskProcessorSchedulerThread::processSchedulingScheduleTasks() {
bool requiringSchedulingTask = true;
if (mConfScheduleTasksDistribution) {
while (requiringSchedulingTask && mTaskSchedulingCount > mCriticalSchedulingThresholdCount && mTaskSchedulingQueue) {
requiringSchedulingTask = false;
cint64 minSchedTasks = 1;
CConcreteTaskSchedulerCommunicator* minSchedulerComm = nullptr;
for (CXLinker* schedulerCommunicatorLinkerIt = mSchedulerCommunicatorLinker; schedulerCommunicatorLinkerIt && minSchedTasks > 0; schedulerCommunicatorLinkerIt = schedulerCommunicatorLinkerIt->getNext()) {
CConcreteTaskSchedulerCommunicator* schedulerComm = schedulerCommunicatorLinkerIt->getData();
if (schedulerComm->requiresSchedulingTasks()) {
requiringSchedulingTask = true;
cint64 schedTasks = schedulerComm->getRequestUpdatedRemainingSchedulingTasksCount();
if (schedTasks <= mCriticalSchedulingThresholdCount) {
if (!minSchedulerComm || schedTasks < minSchedTasks) {
minSchedTasks = schedTasks;
minSchedulerComm = schedulerComm;
}
}
}
}
if (minSchedulerComm) {
requiringSchedulingTask = true;
CTask* task = mTaskSchedulingQueue;
mTaskSchedulingQueue = mTaskSchedulingQueue->getNext();
--mTaskSchedulingCount;
task->clearNext();
minSchedulerComm->communicateProcessTask(task,true,mMemoryAllocator);
minSchedulerComm->incSendedTasks();
}
}
}
return true;
}
bool CTaskProcessorSchedulerThread::processSchedulerScheduleTask(CTask* task, bool schedulingTask) {
if (task) {
if (mWaitingSchedulerItemLinker) {
CConcreteTaskScheduleItem* concreteTaskScheduleItem = mWaitingSchedulerItemLinker;
mWaitingSchedulerItemLinker = mWaitingSchedulerItemLinker->getNext();
CConcreteTaskSchedulerCommunicator* communicator = concreteTaskScheduleItem->getCommunicator();
communicator->communicateProcessTask(task,schedulingTask,mMemoryAllocator);
communicator->incSendedTasks();
mLastScheduledTask = task;
--mDeliveringWaitingCount;
mFreeSchedulerItemLinker = concreteTaskScheduleItem->setNext(mFreeSchedulerItemLinker);
} else {
if (!schedulingTask) {
addProcessingTask(task);
} else {
if (mConfUseReserveTasksQueue) {
mTaskReserveQueue->tryAddTasks(task);
++mTaskReserveQueueCount;
}
if (task) {
if (!mTaskProcessingQueue && !mTaskSchedulingQueue) {
addProcessingTask(task);
} else {
mTaskSchedulingCount += task->getCount();
if (mTaskSchedulingQueue) {
mTaskSchedulingQueue = task->append(mTaskSchedulingQueue);
} else {
mTaskSchedulingQueue = task;
}
if (mTaskSchedulingCount >= mCriticalSchedulingThresholdCount) {
processSchedulingScheduleTasks();
}
}
}
}
}
}
return true;
}
bool CTaskProcessorSchedulerThread::processSchedulerDispenseNotification(CTaskSchedulerCommunicator* communicator) {
processTaskScheduling();
return true;
}
bool CTaskProcessorSchedulerThread::processDispenseNotification() {
if (canDispenseProcessingTasks() && requiresTaskDispenseNotification(mDispenseNotificationTag)) {
processSchedulerDispenseNotification(mSchedulerCommunicator);
}
return true;
}
bool CTaskProcessorSchedulerThread::processRequestProcessTask() {
processSchedulerRequestProcessTask(mSchedulerCommunicator);
return true;
}
bool CTaskProcessorSchedulerThread::processCriticalScheduleTask() {
return true;
}
bool CTaskProcessorSchedulerThread::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);
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++;
} else {
// task completion by completer
mDistributorCompletorCommunicator->communicateTaskComplete(completionTask,mMemoryAllocator);
}
}
}
INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCompletedCount(completedCount));
return true;
}
bool CTaskProcessorSchedulerThread::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 CTaskProcessorSchedulerThread::processResponseScheduleTask(CTask* task, CTaskScheduleItem* taskScheduleItem, bool schedulingTask) {
processSchedulerResponseScheduleTask(task,mSchedulerCommunicator,taskScheduleItem,schedulingTask);
return true;
}
}; // end namespace Scheduler
}; // end namespace Konclude