/*
* 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 "CAnalyseReasonerManager.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Manager {
CAnalyseReasonerManager::CAnalyseReasonerManager(CWatchDog *threadWatchDog) : CReasonerManagerThread(threadWatchDog) {
mWatchDog = threadWatchDog;
}
CAnalyseReasonerManager::~CAnalyseReasonerManager() {
}
void CAnalyseReasonerManager::logQueryProgressUpdates() {
bool activeCalculation = false;
CConcurrentTaskCalculationEnvironment* calcEnv = dynamic_cast(mCalculationManager->getCalculationContext());
if (calcEnv) {
double approxRemainingTasksCount = calcEnv->getCalculationApproximatedRemainingTasksCount();
cint64 computedTasksCount = calcEnv->getCalculationStatisticTasksProcessedCount();
double computedTime = calcEnv->getCalculationComputionTime()/(double)mWorkControllerCount;
if (approxRemainingTasksCount >= 1 && computedTasksCount >= 1 && computedTime >= 1) {
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Calculation progress:"),this);
QHash* mCalcStatHash = mCalculationManager->getCalculationStatistics();
if (mCalcStatHash) {
QString compTime = getLoggingCalculationStatisticsTimeSizeString(mCalcStatHash->value("calculation-computing-time")/(double)mWorkControllerCount);
QString memCons = getLoggingCalculationStatisticsMemorySizeString(mCalcStatHash->value("calculation-memory-consumption"));
QString statString = QString("Up to now calculation computing time: %1, calculation memory consumption: %2")
.arg(compTime)
.arg(memCons);
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString,this);
delete mCalcStatHash;
}
double timePerTask = (double)computedTime/(double)computedTasksCount;
double approxRemainingTime = approxRemainingTasksCount*timePerTask;
QString approxRemainingTimeString;
if (approxRemainingTime > 0) {
approxRemainingTimeString = getLoggingCalculationStatisticsTimeSizeString(approxRemainingTime);
} else {
approxRemainingTimeString = QString("very very long");
}
double progress = computedTasksCount/(approxRemainingTasksCount+computedTasksCount)*100.;
QString statString1 = QString("Processed tasks: %1, approximated remaining tasks: %2")
.arg(computedTasksCount)
.arg(approxRemainingTasksCount);
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString1,this);
QString statString2 = QString("Approximated remaining calculation time: %1, approximated calculation progress: %2 %\r\n")
.arg(approxRemainingTimeString)
.arg(progress);
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString2,this);
activeCalculation = true;
}
}
if (classificationMan) {
CClassificationProgress* classifProgress = classificationMan->getClassificationProgress();
if (classifProgress) {
if (classifProgress->getTestedSatisfiable() != classifProgress->getTotalSatisfiable() || classifProgress->getTestedSubsumptions() != classifProgress->getTotalSubsumptions()) {
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Classification progress:"),this);
QString remainingTimeString = getLoggingCalculationStatisticsTimeSizeString(classifProgress->getRemainingMilliSeconds());
QString statString1 = QString("Finished satisfiable tests: %1, approximated remaining satisfiable tests: %2")
.arg(classifProgress->getTestedSatisfiable())
.arg(classifProgress->getTotalSatisfiable()-classifProgress->getTestedSatisfiable());
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString1,this);
if (classifProgress->getTotalSubsumptions() >= 0) {
QString statString2 = QString("Tested subsumptions: %1, approximated remaining subsumptions to test: %2")
.arg(classifProgress->getTestedSubsumptions())
.arg(classifProgress->getTotalSubsumptions()-classifProgress->getTestedSubsumptions());
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString2,this);
}
QString statString3 = QString("Approximated remaining classification time: %1, approximated classification progress: %2 %\r\n")
.arg(remainingTimeString)
.arg(classifProgress->getProgessPercent());
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString3,this);
activeCalculation = true;
}
}
}
if (mRealizationManager) {
CRealizationProgress* realProgress = mRealizationManager->getRealizationProgress();
if (realProgress) {
if (realProgress->getTestedClasses() != realProgress->getTotalClasses()) {
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",logTr("Realization progress:"),this);
QString remainingTimeString = getLoggingCalculationStatisticsTimeSizeString(realProgress->getRemainingMilliSeconds());
QString statString1 = QString("Tested instantiations: %1, approximated remaining instantiations to test: %2")
.arg(realProgress->getTestedClasses())
.arg(realProgress->getTotalClasses()-realProgress->getTestedClasses());
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString1,this);
QString statString3 = QString("Approximated remaining realization time: %1, approximated realization progress: %2 %\r\n")
.arg(remainingTimeString)
.arg(realProgress->getProgessPercent());
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString3,this);
activeCalculation = true;
}
}
}
if (mAnswererManager) {
CAnsweringProgress* answeringProgress = mAnswererManager->getAnsweringProgress();
if (answeringProgress) {
if (answeringProgress->getTestedInstances() != answeringProgress->getTotalInstances()) {
LOG(INFO, "::Konclude::Reasoner::Kernel::ReasonerManager", logTr("Answering progress:"), this);
QString remainingTimeString = getLoggingCalculationStatisticsTimeSizeString(answeringProgress->getRemainingMilliSeconds());
QString statString1 = QString("Tested instantiations: %1, approximated remaining instantiations to test: %2")
.arg(answeringProgress->getTestedInstances())
.arg(answeringProgress->getTotalInstances() - answeringProgress->getTestedInstances());
LOG(INFO, "::Konclude::Reasoner::Kernel::ReasonerManager", statString1, this);
QString statString3 = QString("Approximated remaining answering time: %1, approximated answering progress: %2 %\r\n")
.arg(remainingTimeString)
.arg(answeringProgress->getProgessPercent());
LOG(INFO, "::Konclude::Reasoner::Kernel::ReasonerManager", statString3, this);
activeCalculation = true;
}
}
}
if (activeCalculation) {
if (mSatExpCache) {
CCacheStatistics* cacheStats = mSatExpCache->getCacheStatistics();
QString statString3 = QString("Satisfiable-Expander-Cache statistics: %1 cache entries, %2 memory consumption")
.arg(cacheStats->getCacheEntriesCount())
.arg(getLoggingCalculationStatisticsMemorySizeString(cacheStats->getMemoryConsumption()));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString3,this);
}
if (unsatCache) {
CCacheStatistics* cacheStats = unsatCache->getCacheStatistics();
QString statString3 = QString("Unsatisfiable-Cache statistics: %1 cache entries, %2 memory consumption\r\n")
.arg(cacheStats->getCacheEntriesCount())
.arg(getLoggingCalculationStatisticsMemorySizeString(cacheStats->getMemoryConsumption()));
LOG(INFO,"::Konclude::Reasoner::Kernel::ReasonerManager",statString3,this);
}
}
}
double CAnalyseReasonerManager::getQueryProgress() {
double progressPercent = 100;
//double allTotalWork = 0;
//double allClosedWork = 0;
//CConcurrentWorkCalculationEnvironment *conCalcContext = dynamic_cast(mCalculationManager->getCalculationContext());
//CWorkRegistry *registry = conCalcContext->getWorkRegistry();
//workSyncMutex.lock();
//QList queryList = mCalculatingQuerySet.values();
//workSyncMutex.unlock();
//foreach (CQuery *query, queryList) {
// CWorkProvidedQuery *workQuery = dynamic_cast(query);
// if (workQuery) {
// double totWorkCount = 0;
// double closWorkCount = 0;
// QLinkedList workList = workQuery->getWorkList();
// foreach (CWork *work, workList) {
// CWorkLock *workLock = registry->getWorkLock(work);
// if (workLock) {
// CCalcBoxProcessWork *calcWork = dynamic_cast(work);
// if (calcWork) {
// closWorkCount += calcWork->getApproximatedClosedWorkCount();
// totWorkCount += calcWork->getApproximatedTotalWorkCount();
// }
// workLock->releaseLock();
// delete workLock;
// }
// }
// allTotalWork += totWorkCount;
// allClosedWork += closWorkCount;
// }
//}
//if (allTotalWork > 0) {
// progressPercent = allClosedWork / allTotalWork * 100.;
//}
return progressPercent;
}
double CAnalyseReasonerManager::getQueryTotalWorkCount() {
double allTotalWork = 0;
//double allClosedWork = 0;
//CConcurrentWorkCalculationEnvironment *conCalcContext = dynamic_cast(mCalculationManager->getCalculationContext());
//CWorkRegistry *registry = conCalcContext->getWorkRegistry();
//workSyncMutex.lock();
//QList queryList = mCalculatingQuerySet.values();
//workSyncMutex.unlock();
//foreach (CQuery *query, queryList) {
// CWorkProvidedQuery *workQuery = dynamic_cast(query);
// if (workQuery) {
// double totWorkCount = 0;
// double closWorkCount = 0;
// QLinkedList workList = workQuery->getWorkList();
// foreach (CWork *work, workList) {
// CWorkLock *workLock = registry->getWorkLock(work);
// if (workLock) {
// CCalcBoxProcessWork *calcWork = dynamic_cast(work);
// if (calcWork) {
// closWorkCount += calcWork->getApproximatedClosedWorkCount();
// totWorkCount += calcWork->getApproximatedTotalWorkCount();
// }
// workLock->releaseLock();
// delete workLock;
// }
// }
// allTotalWork += totWorkCount;
// allClosedWork += closWorkCount;
// }
//}
return allTotalWork;
}
double CAnalyseReasonerManager::getQueryCalculatedWorkCount() {
double allTotalWork = 0;
double allClosedWork = 0;
//CConcurrentWorkCalculationEnvironment *conCalcContext = dynamic_cast(mCalculationManager->getCalculationContext());
//CWorkRegistry *registry = conCalcContext->getWorkRegistry();
//workSyncMutex.lock();
//QList queryList = mCalculatingQuerySet.values();
//workSyncMutex.unlock();
//foreach (CQuery *query, queryList) {
// CWorkProvidedQuery *workQuery = dynamic_cast(query);
// if (workQuery) {
// double totWorkCount = 0;
// double closWorkCount = 0;
// QLinkedList workList = workQuery->getWorkList();
// foreach (CWork *work, workList) {
// CWorkLock *workLock = registry->getWorkLock(work);
// if (workLock) {
// CCalcBoxProcessWork *calcWork = dynamic_cast(work);
// if (calcWork) {
// closWorkCount += calcWork->getApproximatedClosedWorkCount();
// totWorkCount += calcWork->getApproximatedTotalWorkCount();
// }
// workLock->releaseLock();
// delete workLock;
// }
// }
// allTotalWork += totWorkCount;
// allClosedWork += closWorkCount;
// }
//}
return allClosedWork;
}
}; // end namespace Manager
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude