/*
* 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 "CConcurrentTaskCalculationEnvironment.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Calculation {
CConcurrentTaskCalculationEnvironment::CConcurrentTaskCalculationEnvironment() {
mProcessUnit = nullptr;
mSchedulerUnit = nullptr;
mCompletorUnit = nullptr;
mCallbackExecuter = nullptr;
mStatusPropagator = nullptr;
mAllocationLimitation = nullptr;
mTaskCreatedDepthCountVec.resize(CTaskProcessingStatistics::VECCOUNTERSIZE);
mTaskProcessedDepthCountVec.resize(CTaskProcessingStatistics::VECCOUNTERSIZE);
mTaskRelativeIncreaseTaskPerDepthVec.resize(CTaskProcessingStatistics::VECCOUNTERSIZE);
mTaskTotalIncreaseTaskPerDepthVec.resize(CTaskProcessingStatistics::VECCOUNTERSIZE);
}
CConcurrentTaskCalculationEnvironment::~CConcurrentTaskCalculationEnvironment() {
qDeleteAll(mProcessorUnitList);
mProcessorUnitList.clear();
}
CConcurrentTaskCalculationEnvironment* CConcurrentTaskCalculationEnvironment::initSingleTaskProcessor(CSingleThreadTaskProcessorUnit* processUnit) {
mProcessUnit = processUnit;
mSchedulerUnit = mProcessUnit;
mCompletorUnit = mProcessUnit;
mProcessorUnitList.append(mProcessUnit);
return this;
}
CConcurrentTaskCalculationEnvironment* CConcurrentTaskCalculationEnvironment::initMultiTaskProcessor(CTaskProcessorSchedulerThread* schedulerUnit, CTaskProcessorCompletorThread* completorUnit) {
mProcessUnit = nullptr;
mSchedulerUnit = schedulerUnit;
mCompletorUnit = completorUnit;
mProcessorUnitList.append(schedulerUnit);
mProcessorUnitList.append(completorUnit);
mThreadUnitList.append(schedulerUnit);
mThreadUnitList.append(completorUnit);
return this;
}
CConcurrentTaskCalculationEnvironment* CConcurrentTaskCalculationEnvironment::appendMultiTaskProcessor(CTaskProcessorThread* processorUnit) {
mProcessorUnitList.append(processorUnit);
mThreadUnitList.append(processorUnit);
return this;
}
CConcurrentTaskCalculationEnvironment* CConcurrentTaskCalculationEnvironment::initCallbackExecuter(CSatisfiableCalculationTaskJobCallbackExecuter* callbackExecuter) {
mCallbackExecuter = callbackExecuter;
return this;
}
CConcurrentTaskCalculationEnvironment* CConcurrentTaskCalculationEnvironment::initStatusPropagator(CSatisfiableCalculationTaskStatusPropagator* statusPropagator) {
mStatusPropagator = statusPropagator;
return this;
}
CConcurrentTaskCalculationEnvironment* CConcurrentTaskCalculationEnvironment::setAllocationLimitation(CCentralizedAllocationLimitation* allocationLimitation) {
mAllocationLimitation = allocationLimitation;
return this;
}
CSatisfiableCalculationTaskJobCallbackExecuter* CConcurrentTaskCalculationEnvironment::getSatisfiableCalculationTaskJobCallbackExecuter() {
return mCallbackExecuter;
}
CSatisfiableCalculationTaskStatusPropagator* CConcurrentTaskCalculationEnvironment::getSatisfiableCalculationTaskStatusPropagator() {
return mStatusPropagator;
}
CSingleThreadTaskProcessorUnit* CConcurrentTaskCalculationEnvironment::getSingleTaskProcessorUnit() {
return mProcessUnit;
}
CTaskEventHandlerBasedScheduler* CConcurrentTaskCalculationEnvironment::getSchedulerTaskProcessorUnit() {
return mSchedulerUnit;
}
CTaskEventHandlerBasedCompletor* CConcurrentTaskCalculationEnvironment::getCompletorTaskProcessorUnit() {
return mCompletorUnit;
}
QList CConcurrentTaskCalculationEnvironment::getTaskProcessorUnitList() {
return mProcessorUnitList;
}
CCentralizedAllocationLimitation* CConcurrentTaskCalculationEnvironment::getAllocationLimitation() {
return mAllocationLimitation;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationComputionTime() {
cint64 compTime = 0;
if (mProcessUnit) {
compTime += mProcessUnit->getStatisticComputionTime();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
compTime += threadUnit->getStatisticComputionTime();
}
return compTime;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationBlockingTime() {
cint64 compTime = 0;
if (mProcessUnit) {
compTime += mProcessUnit->getStatisticBlockingTime();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
compTime += threadUnit->getStatisticBlockingTime();
}
return compTime;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationMemoryConsumption() {
cint64 memComp = 0;
memComp = mAllocationLimitation->getAllocatedMemorySizeMaximum();
return memComp;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationMemoryReserved() {
cint64 memComp = 0;
memComp = mAllocationLimitation->getReservedMemorySizeMaximum();
return memComp;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticTasksProcessedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksProcessedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticTasksProcessedCount();
}
return statVal;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticTasksAddedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksAddedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticTasksAddedCount();
}
return statVal;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticTasksCreatedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksCreatedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticTasksCreatedCount();
}
return statVal;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticTasksCompletedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksCompletedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticTasksCompletedCount();
}
return statVal;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticTasksUpdatedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksUpdatedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticTasksUpdatedCount();
}
return statVal;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticEventsProcessedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticEventsProcessedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticEventsProcessedCount();
}
return statVal;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticTasksRequestedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksRequestedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticTasksRequestedCount();
}
return statVal;
}
cint64 CConcurrentTaskCalculationEnvironment::getCalculationStatisticThreadsBlockedCount() {
cint64 statVal = 0;
if (mProcessUnit) {
statVal += mProcessUnit->getTaskProcessingStatistics()->getStatisticThreadsBlockedCount();
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
statVal += threadUnit->getTaskProcessingStatistics()->getStatisticThreadsBlockedCount();
}
return statVal;
}
double CConcurrentTaskCalculationEnvironment::getCalculationApproximatedRemainingTasksCount() {
double remainingTasksCount = 0;
for (cint64 i = 0; i < CTaskProcessingStatistics::VECCOUNTERSIZE; ++i) {
mTaskCreatedDepthCountVec[i] = 0;
mTaskProcessedDepthCountVec[i] = 0;
mTaskRelativeIncreaseTaskPerDepthVec[i] = 0.;
mTaskTotalIncreaseTaskPerDepthVec[i] = 1.;
}
if (mProcessUnit) {
QVector* createdVec = mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksCreatedDepthCountVector();
QVector* processedVec = mProcessUnit->getTaskProcessingStatistics()->getStatisticTasksProcessedDepthCountVector();
for (cint64 i = 0; i < CTaskProcessingStatistics::VECCOUNTERSIZE; ++i) {
mTaskCreatedDepthCountVec[i] += (*createdVec)[i];
mTaskProcessedDepthCountVec[i] += (*processedVec)[i];
}
}
foreach (CTaskProcessorThreadBase* threadUnit, mThreadUnitList) {
QVector* createdVec = threadUnit->getTaskProcessingStatistics()->getStatisticTasksCreatedDepthCountVector();
QVector* processedVec = threadUnit->getTaskProcessingStatistics()->getStatisticTasksProcessedDepthCountVector();
for (cint64 i = 0; i < CTaskProcessingStatistics::VECCOUNTERSIZE; ++i) {
mTaskCreatedDepthCountVec[i] += (*createdVec)[i];
mTaskProcessedDepthCountVec[i] += (*processedVec)[i];
}
}
for (cint64 i = 0; i < CTaskProcessingStatistics::VECCOUNTERSIZE-1; ++i) {
cint64 processedTaskCount = mTaskProcessedDepthCountVec[i];
cint64 nextDepthCreatedCount = mTaskCreatedDepthCountVec[i+1];
double relIncTaskRate = 0;
if (nextDepthCreatedCount) {
if (processedTaskCount < 1) {
processedTaskCount = 1;
mTaskProcessedDepthCountVec[i] = processedTaskCount;
}
relIncTaskRate = (double)nextDepthCreatedCount/(double)processedTaskCount;
}
mTaskRelativeIncreaseTaskPerDepthVec[i] = relIncTaskRate;
}
for (cint64 i = CTaskProcessingStatistics::VECCOUNTERSIZE-1; i >= 0; --i) {
double relIncValue = mTaskRelativeIncreaseTaskPerDepthVec[i];
if (relIncValue > 0.) {
double nextTotIncValue = mTaskTotalIncreaseTaskPerDepthVec[i+1];
if (nextTotIncValue > 0.) {
mTaskTotalIncreaseTaskPerDepthVec[i] = 1 + nextTotIncValue * relIncValue;
} else {
mTaskTotalIncreaseTaskPerDepthVec[i] = relIncValue;
}
}
}
for (cint64 i = 0; i < CTaskProcessingStatistics::VECCOUNTERSIZE-1; ++i) {
cint64 openTaskCount = mTaskCreatedDepthCountVec[i] - mTaskProcessedDepthCountVec[i];
if (openTaskCount > 0) {
remainingTasksCount += openTaskCount * mTaskTotalIncreaseTaskPerDepthVec[i];
}
}
QStringList debugStringList;
for (cint64 i = 0; i < CTaskProcessingStatistics::VECCOUNTERSIZE-1; ++i) {
QString depthString = QString("Depth: %1, C:%2, P:%3, +:%4, *%5").arg(i).arg(mTaskCreatedDepthCountVec[i]).arg(mTaskProcessedDepthCountVec[i])
.arg(mTaskRelativeIncreaseTaskPerDepthVec[i]).arg(mTaskTotalIncreaseTaskPerDepthVec[i]);
debugStringList.append(depthString);
}
QString debugString = debugStringList.join("\r\n");
return remainingTasksCount;
}
}; // end namespace Calculation
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude