Debian Codegraph @

Source/Reasoner/Kernel/Calculation/CConcurrentTaskCalculationManager.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 "CConcurrentTaskCalculationManager.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Calculation {
31
32
33 CConcurrentTaskCalculationManager::CConcurrentTaskCalculationManager(CWatchDog *watchDog) {
34 calcContext = nullptr;
35 mTaskCalcEn = nullptr;
36 mGenTaskHandleContext = nullptr;
37 mTemMemMan = nullptr;
38 }
39
40 CCalculationManager *CConcurrentTaskCalculationManager::calculateTask(CSatisfiableCalculationTask* task) {
41 if (mTaskCalcEn) {
42 CTaskEventCommunicator::postSendTaskScheduleEvent(mTaskCalcEn->getSchedulerTaskProcessorUnit()->getEventHandler(),task,mTemMemMan);
43 }
44 return this;
45 }
46
47 CCalculationManager *CConcurrentTaskCalculationManager::calculateJob(CCalculationJob* job, CCallbackData* callbackData) {
48 CSatisfiableCalculationTaskFromCalculationJobGenerator gen(mGenTaskHandleContext);
49 CSatisfiableCalculationTask* task = gen.createSatisfiableCalculationTask(job,callbackData);
50 if (task) {
51 calculateTask(task);
52 }
53 return this;
54 }
55
56 CCalculationManager* CConcurrentTaskCalculationManager::calculateJobs(const QList< QPair<CCalculationJob*,CCallbackData*> >& jobCallbackList) {
57 CSatisfiableCalculationTask* taskLinker = nullptr;
58 CSatisfiableCalculationTaskFromCalculationJobGenerator gen(mGenTaskHandleContext);
59 for (QList< QPair<CCalculationJob*,CCallbackData*> >::const_iterator it = jobCallbackList.constBegin(), itEnd = jobCallbackList.constEnd(); it != itEnd; ++it) {
60 QPair<CCalculationJob*,CCallbackData*> jobCallbackPair(*it);
61 CCalculationJob* job(jobCallbackPair.first);
62 CCallbackData* callbackData(jobCallbackPair.second);
63 CSatisfiableCalculationTask* task = gen.createSatisfiableCalculationTask(job,callbackData);
64 if (task) {
65 taskLinker = (CSatisfiableCalculationTask*)task->append(taskLinker);
66 }
67 }
68 if (taskLinker) {
69 calculateTask(taskLinker);
70 }
71 return this;
72 }
73
74 CCalculationManager *CConcurrentTaskCalculationManager::initializeManager(CCalculationEnvironmentFactory *contextFactory, CConfigurationProvider *configurationProvider) {
75 CConfigurationBase *config = 0;
76 calcContext = contextFactory->createCalculationContext(configurationProvider);
77 mTaskCalcEn = dynamic_cast<CConcurrentTaskCalculationEnvironment*>(calcContext);
78 mGenTaskHandleContext = new CGeneratorTaskHandleContextBase();
79 mTemMemMan = mGenTaskHandleContext->getTaskHandleMemoryAllocationManager();
80 return this;
81 }
82
83 CCalculationEnviroment *CConcurrentTaskCalculationManager::getCalculationContext() {
84 return calcContext;
85 }
86
87
88 QString CConcurrentTaskCalculationManager::getCalculationErrorString(cint64 errorCode) {
89 switch (errorCode) {
90 case 1: {
91 return QString("Nominal couldn't be resolved.");
92 }
93 case 2: {
94 return QString("Memory allocation failed / out of memory / memory allocation limit reached.");
95 }
96 case 3: {
97 return QString("Unknow fatal error.");
98 }
99 }
100 return QString("Unknown error.");
101 }
102
103
104 QHash<QString,cint64>* CConcurrentTaskCalculationManager::getCalculationStatistics() {
105 QHash<QString,cint64>* statHash = new QHash<QString,cint64>();
106 CConcurrentTaskCalculationEnvironment* conTaskEnv = dynamic_cast<CConcurrentTaskCalculationEnvironment*>(calcContext);
107 if (conTaskEnv) {
108 statHash->insert(QString("calculation-computing-time"),conTaskEnv->getCalculationComputionTime());
109 statHash->insert(QString("calculation-blocking-time"),conTaskEnv->getCalculationBlockingTime());
110 statHash->insert(QString("calculation-memory-consumption"),conTaskEnv->getCalculationMemoryConsumption());
111 statHash->insert(QString("calculation-memory-reservation"),conTaskEnv->getCalculationMemoryReserved());
112
113 statHash->insert(QString("calculation-tasks-processed-count"),conTaskEnv->getCalculationStatisticTasksProcessedCount());
114 statHash->insert(QString("calculation-tasks-created-count"),conTaskEnv->getCalculationStatisticTasksCreatedCount());
115 statHash->insert(QString("calculation-tasks-added-count"),conTaskEnv->getCalculationStatisticTasksAddedCount());
116 statHash->insert(QString("calculation-tasks-updated-count"),conTaskEnv->getCalculationStatisticTasksUpdatedCount());
117 statHash->insert(QString("calculation-tasks-completed-count"),conTaskEnv->getCalculationStatisticTasksCompletedCount());
118 statHash->insert(QString("calculation-tasks-requested-count"),conTaskEnv->getCalculationStatisticTasksRequestedCount());
119 statHash->insert(QString("calculation-threads-blocking-count"),conTaskEnv->getCalculationStatisticThreadsBlockedCount());
120 statHash->insert(QString("calculation-threads-events-processed-count"),conTaskEnv->getCalculationStatisticEventsProcessedCount());
121 }
122 return statHash;
123 }
124
125 QHash<QString,cint64>* CConcurrentTaskCalculationManager::getUpdatedCalculationStatistics(QHash<QString,cint64>* stat) {
126 QHash<QString,cint64>* statHash = new QHash<QString,cint64>();
127 CConcurrentTaskCalculationEnvironment* conTaskEnv = dynamic_cast<CConcurrentTaskCalculationEnvironment*>(calcContext);
128 if (conTaskEnv && stat) {
129 statHash->insert(QString("calculation-computing-time"),conTaskEnv->getCalculationComputionTime() - stat->value("calculation-computing-time",0));
130 statHash->insert(QString("calculation-blocking-time"),conTaskEnv->getCalculationBlockingTime() - stat->value("calculation-blocking-time",0));
131 statHash->insert(QString("calculation-memory-consumption"),conTaskEnv->getCalculationMemoryConsumption());
132 statHash->insert(QString("calculation-memory-reservation"),conTaskEnv->getCalculationMemoryReserved());
133
134 statHash->insert(QString("calculation-tasks-processed-count"),conTaskEnv->getCalculationStatisticTasksProcessedCount() - stat->value("calculation-tasks-processed-count",0));
135 statHash->insert(QString("calculation-tasks-created-count"),conTaskEnv->getCalculationStatisticTasksCreatedCount() - stat->value("calculation-tasks-created-count",0));
136 statHash->insert(QString("calculation-tasks-added-count"),conTaskEnv->getCalculationStatisticTasksAddedCount() - stat->value("calculation-tasks-added-count",0));
137 statHash->insert(QString("calculation-tasks-updated-count"),conTaskEnv->getCalculationStatisticTasksUpdatedCount() - stat->value("calculation-tasks-updated-count",0));
138 statHash->insert(QString("calculation-tasks-completed-count"),conTaskEnv->getCalculationStatisticTasksCompletedCount() - stat->value("calculation-tasks-completed-count",0));
139 statHash->insert(QString("calculation-tasks-requested-count"),conTaskEnv->getCalculationStatisticTasksRequestedCount() - stat->value("calculation-tasks-requested-count",0));
140 statHash->insert(QString("calculation-threads-blocking-count"),conTaskEnv->getCalculationStatisticThreadsBlockedCount() - stat->value("calculation-threads-blocking-count",0));
141 statHash->insert(QString("calculation-threads-events-processed-count"),conTaskEnv->getCalculationStatisticEventsProcessedCount() - stat->value("calculation-threads-events-processed-count",0));
142 }
143 return statHash;
144 }
145
146 double CConcurrentTaskCalculationManager::getCalculationApproximatedRemainingTasksCount() {
147 CConcurrentTaskCalculationEnvironment* conTaskEnv = dynamic_cast<CConcurrentTaskCalculationEnvironment*>(calcContext);
148 if (conTaskEnv) {
149 return conTaskEnv->getCalculationApproximatedRemainingTasksCount();
150 }
151 return 0.;
152 }
153
154
155 }; // end namespace Calculation
156
157 }; // end namespace Kernel
158
159 }; // end namespace Reasoner
160
161 }; // end namespace Konclude