Debian Codegraph @

Source/Scheduler/CTaskProcessorCompletorThread.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CTaskProcessorCompletorThread.h"
22
23
24 namespace Konclude {
25
26 namespace Scheduler {
27
28
29
30 CTaskProcessorCompletorThread::CTaskProcessorCompletorThread(CTaskHandleAlgorithm* taskHandleAlgo, CConsiderateMemoryPoolProvider* memoryPoolProvider) : CTaskProcessorThreadBase(taskHandleAlgo,"TaskProcesserCompletorThread"),CConcreteMemoryPoolDistributor(nullptr) {
31 mMemoryPoolReleaser = new CDirectDistributionMemoryPoolReleaser(this);
32 mMemoryPoolProvider = memoryPoolProvider;
33 if (!mMemoryPoolProvider) {
34 //mMemoryPoolProvider = CConcreteMemoryPoolDistributor::createDistributionMemoryPoolProvider(mMemoryPoolReleaser);
35 mMemoryPoolProvider = new CNewAllocationMemoryPoolProvider();
36 }
37 mMemoryAllocator = new CTaskHandleLimitedReserveMemoryPoolAllocationManager(mMemoryPoolProvider,80000,30);
38 mTaskProcessorContext = new CTaskProcessorContextBase(this,mMemoryAllocator);
39
40 mSchedulerCommunicator = nullptr;
41 mDispenseNotificationTag = 0;
42 }
43
44 CTaskProcessorCompletorThread::~CTaskProcessorCompletorThread() {
45 }
46
47
48 CTaskEventHandlerBasedProcessor* CTaskProcessorCompletorThread::installScheduler(CTaskEventHandlerBasedScheduler* scheduler) {
49 mTaskReserveQueueConsumer = scheduler->createTaskReserveQueueConsumer(this);
50 CTaskSchedulerCommunicator* schedulerCommunicator = scheduler->createSchedulerProcessorCommunication(this);
51 installSchedulerCommunicator(schedulerCommunicator);
52 return this;
53 }
54
55 CTaskProcessorCompletorThread* CTaskProcessorCompletorThread::installSchedulerCommunicator(CTaskSchedulerCommunicator* schedulerCommunicator) {
56 mSchedulerCommunicator = schedulerCommunicator;
57 mSchedulerCommunicator->communicateRequestProcessTask(mMemoryAllocator);
58 return this;
59 }
60
61 CDistributionMemoryPoolProvider* CTaskProcessorCompletorThread::createDistributionMemoryPoolProvider(CDistributionMemoryPoolReleaser* distributionMemoryReleaser) {
62 return CConcreteMemoryPoolDistributor::createDistributionMemoryPoolProvider(distributionMemoryReleaser);
63 }
64
65 CConcreteMemoryPoolDistributor* CTaskProcessorCompletorThread::distributeMemoryPools(CMemoryPool* memoryPools) {
66 return CConcreteMemoryPoolDistributor::distributeMemoryPools(memoryPools);
67 }
68
69
70 bool CTaskProcessorCompletorThread::processEvent(CEvent *event, CContext* handlerContext) {
71 mLastProcessedEvent = event;
72 cint64 eventID = event->getEventTypeID();
73 if (eventID == CTaskStatusUpdatedEvent::EVENTTYPEID) {
74 CTaskStatusUpdatedEvent* tsue = (CTaskStatusUpdatedEvent*)event;
75 CTask* parentTask = tsue->getParentTask();
76 CTask* updatedTask = tsue->getUpdatedTask();
77 bool updateSuccess = tsue->getUpdateSuccess();
78 processTaskStatusUpdated(parentTask,updatedTask,updateSuccess);
79 return true;
80 } else if (eventID == CAlignedUpdateTaskStatusEvent::EVENTTYPEID) {
81 CAlignedUpdateTaskStatusEvent* autse = (CAlignedUpdateTaskStatusEvent*)event;
82 CTask* updateTask = autse->getUpdateTask();
83 processUpdateTaskStatus(updateTask);
84 return true;
85 } else if (CTaskProcessorThreadBase::processEvent(event,handlerContext)) {
86 return true;
87 } else {
88 // not supported event
89 }
90 return false;
91 }
92
93
94
95 bool CTaskProcessorCompletorThread::processDispenseNotification() {
96 if (canDispenseProcessingTasks() && mSchedulerCommunicator->requiresTaskDispenseNotification(mDispenseNotificationTag)) {
97 mSchedulerCommunicator->communicateTaskDispenseNotification(mMemoryAllocator);
98 }
99 return true;
100 }
101
102
103 bool CTaskProcessorCompletorThread::processRequestProcessTask() {
104 mSchedulerCommunicator->communicateRequestProcessTask(mMemoryAllocator);
105 return true;
106 }
107
108 bool CTaskProcessorCompletorThread::processCriticalScheduleTask() {
109 mSchedulerCommunicator->communicateCriticalScheduleTask(mMemoryAllocator);
110 return true;
111 }
112
113
114 bool CTaskProcessorCompletorThread::processCompleteTask(CTask* task) {
115 cint64 completedCount = 0;
116 mTaskCompletionQueue = task->getLastListLink()->setNext(mTaskCompletionQueue);
117 while (mTaskCompletionQueue) {
118 CTask* completionTask = mTaskCompletionQueue;
119 mTaskCompletionQueue = mTaskCompletionQueue->getNext();
120
121 if (completionTask) {
122 if (completionTask->hasDependedStatusUpdates()) {
123 completionTask->setCompletionRequested(true);
124 } else if (!completionTask->hasActiveReferencedTask()) {
125
126 CTask* parentTask = completionTask->getParentTask();
127 bool upPropagation = false;
128 if (mTaskStatusPropagator && mTaskStatusPropagator->completeTaskStatus(completionTask,upPropagation)) {
129 if (parentTask && upPropagation) {
130 processUpdateTaskStatus(parentTask);
131 }
132 }
133 completionTask->completeTask();
134 completionTask->getTaskStatus()->setTaskCOMPLETEDState();
135 bool memoryReleaseable = completionTask->getTaskStatus()->isMemoryReleaseable();
136 if (parentTask) {
137 parentTask->decActiveReferenceCount();
138 if (!parentTask->hasActiveReferencedTask()) {
139 mTaskCompletionQueue = parentTask->setNext(mTaskCompletionQueue);
140 }
141 }
142 if (completionTask) {
143 // callbacks
144 CCallbackData* callbackLinkerIt = completionTask->getCallbackLinker();
145 while (callbackLinkerIt) {
146 CCallbackData* callback = callbackLinkerIt;
147 callbackLinkerIt = callbackLinkerIt->getNext();
148 if (mCallbackExecuter) {
149 mCallbackExecuter->executeCallback(completionTask,callback);
150 INCTASKPROCESSINGSTAT(mStats.incStatisticCallbacksExecutedCount(1));
151 } else {
152 callback->doCallback();
153 }
154 }
155 }
156 #ifndef KONCLUDE_SCHEDULER_DEBUG_TASK_MEMORY_RELEASE
157 if (memoryReleaseable) {
158 for (CDeletionLinker* deletionLinkerIt = completionTask->takeDeletionLinker(); deletionLinkerIt; deletionLinkerIt = deletionLinkerIt->getNext()) {
159 deletionLinkerIt->deleteObject();
160 }
161 mMemoryAllocator->releaseMemoryPoolContainer(completionTask);
162 }
163 #endif
164 completedCount++;
165 }
166 }
167
168 }
169 INCTASKPROCESSINGSTAT(mStats.incStatisticTasksCompletedCount(completedCount));
170 return true;
171 }
172
173
174 bool CTaskProcessorCompletorThread::processAdditionalTaskAllocation(CTask* task, CMemoryPool* memoryPool) {
175 task->appendMemoryPool(memoryPool);
176 return true;
177 }
178
179 bool CTaskProcessorCompletorThread::processResponseScheduleTask(CTask* task, CTaskScheduleItem* taskScheduleItem, bool schedulingTask) {
180 mSchedulerCommunicator->communicateResponseScheduleTask(taskScheduleItem,task,schedulingTask,mMemoryAllocator);
181 return true;
182 }
183
184 bool CTaskProcessorCompletorThread::processTaskStatusUpdated(CTask* parentTask, CTask* updatedTask, bool updateSuccess) {
185 bool needsMayTaskCompletion = false;
186 if (updateSuccess) {
187 parentTask->decDependedStatusUpdatesCount();
188 needsMayTaskCompletion = true;
189 } else {
190 // task is already completed or is now owned by completer
191 // check whether task is completed
192 bool taskCompleted = false;
193 CXNegLinker<CTask*>* refTaskLinkerIt = parentTask->getReferencedTaskLinker();
194 while (refTaskLinkerIt) {
195 CTask* refTask = refTaskLinkerIt->getData();
196 if (refTask == updatedTask) {
197 if (!refTaskLinkerIt->isNegated()) {
198 taskCompleted = true;
199 }
200 break;
201 }
202 refTaskLinkerIt = refTaskLinkerIt->getNext();
203 }
204 if (taskCompleted) {
205 parentTask->decDependedStatusUpdatesCount();
206 needsMayTaskCompletion = true;
207 } else {
208 if (parentTask->hasTaskOwner(this) || !parentTask->hasTaskOwner()) {
209 processUpdateTaskStatus(parentTask,updatedTask);
210 needsMayTaskCompletion = true;
211 } else {
212 mSchedulerCommunicator->communicateScheduleUpdateTaskStatus(parentTask,updatedTask,mMemoryAllocator);
213 }
214 }
215 }
216 if (needsMayTaskCompletion) {
217 if (parentTask->isCompletionRequested()) {
218 if (!parentTask->hasDependedStatusUpdates()) {
219 processCompleteTask(parentTask);
220 }
221 }
222 }
223 return true;
224 }
225
226 bool CTaskProcessorCompletorThread::processUpdateTaskStatus(CTask* parentTask, CTask* updateTask) {
227 if (!parentTask || parentTask->hasTaskOwner(this) || !parentTask->hasTaskOwner()) {
228 // local task status update
229 processUpdateTaskStatus(updateTask);
230 processTaskStatusUpdated(parentTask,updateTask,true);
231 } else {
232 processTaskStatusUpdated(parentTask,updateTask,false);
233 }
234 return true;
235 }
236
237
238 bool CTaskProcessorCompletorThread::processUpdateTaskStatus(CTask* task) {
239 CTask* updateTask = task;
240 bool downProp = false;
241 bool upProp = false;
242 CTaskOwner* taskOwner = updateTask->getTaskOwner();
243 if (mTaskStatusPropagator && mTaskStatusPropagator->updateTaskStatus(updateTask,downProp,upProp)) {
244 if (downProp) {
245 if (taskOwner == nullptr || taskOwner == this) {
246 // update task status direct
247 CXNegLinker<CTask*>* refTaskIt = updateTask->getReferencedTaskLinker();
248 while (refTaskIt) {
249 if (refTaskIt->isNegated()) {
250 // task still exists, update task status
251 // TODO: check better not recursive?
252 CTask* refTask = refTaskIt->getData();
253 processUpdateTaskStatus(refTask);
254 }
255 refTaskIt = refTaskIt->getNext();
256 }
257 } else {
258 // signalize task status update per event to other processing units
259 CXNegLinker<CTask*>* refTaskIt = updateTask->getReferencedTaskLinker();
260 while (refTaskIt) {
261 if (refTaskIt->isNegated()) {
262 // task still exists, update task status with event to corresponding processor unit
263 CTask* refTask = refTaskIt->getData();
264 updateTask->incDependedStatusUpdatesCount();
265 mSchedulerCommunicator->communicateScheduleUpdateTaskStatus(updateTask,refTask,mMemoryAllocator);
266 }
267 refTaskIt = refTaskIt->getNext();
268 }
269 }
270 }
271 if (upProp) {
272 // all parent task are owned by the completer
273 CTask* parentTask = updateTask->getParentTask();
274 if (parentTask) {
275 processUpdateTaskStatus(parentTask);
276 }
277 }
278 }
279 return true;
280 }
281
282
283
284 }; // end namespace Scheduler
285
286 }; // end namespace Konclude