/* * 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 . * */ #ifndef KONCLUDE_REASONER_KERNEL_MANAGER_CREASONERMANAGERTHREAD_H #define KONCLUDE_REASONER_KERNEL_MANAGER_CREASONERMANAGERTHREAD_H // Qt includes #include #include // Namespace includes #include "CReasonerManager.h" #include "CPrecomputationManager.h" #include "CPreprocessingManager.h" #include "COntologyRequirementPair.h" #include "CRequirementPreparingData.h" #include "CReasoningTaskData.h" #include "CRealizationManager.h" // Other includes #include "Reasoner/Kernel/Calculation/CCalculationManager.h" #include "Reasoner/Kernel/Calculation/CConfigDependedCalculationEnvironmentFactory.h" #include "Reasoner/Kernel/Calculation/CTaskHandleAlgorithmBuilder.h" #include "Reasoner/Kernel/Calculation/CConfigDependedCalculationFactory.h" #include "Reasoner/Kernel/Algorithm/CCalculationTableauCompletionTaskHandleAlgorithm.h" #include "Reasoner/Kernel/Algorithm/CCalculationTableauApproximationSaturationTaskHandleAlgorithm.h" #include "Reasoner/Kernel/Algorithm/CCalculationChooseTaskHandleAlgorithm.h" #include "Reasoner/Kernel/Algorithm/CUnsatisfiableCacheHandler.h" #include "Reasoner/Kernel/Algorithm/CSatisfiableExpanderCacheHandler.h" #include "Reasoner/Kernel/Algorithm/CReuseCompletionGraphCacheHandler.h" #include "Reasoner/Kernel/Algorithm/CSaturationNodeExpansionCacheHandler.h" #include "Reasoner/Kernel/Algorithm/CSaturationNodeBackendAssociationCacheHandler.h" #include "Reasoner/Kernel/Algorithm/CIndividualNodeBackendCacheHandler.h" #include "Reasoner/Ontology/COntologyProcessingRequirementExpander.h" #include "Reasoner/Ontology/COntologyProcessingStepRequirement.h" #include "Reasoner/Ontology/COntologyProcessingStepVector.h" #include "Reasoner/Ontology/COntologyProcessingConceptSaturationRequirement.h" #include "Reasoner/Query/CJobSatisfiableCallbackContextData.h" #include "Reasoner/Query/CJobProvidedQuery.h" #include "Reasoner/Query/CRealizationPremisingQuery.h" #include "Reasoner/Query/CTaxonomyPremisingQuery.h" #include "Reasoner/Query/CConsistencePremisingQuery.h" #include "Reasoner/Query/CQueryInconsitentOntologyError.h" #include "Reasoner/Query/CQueryUnspecifiedStringError.h" #include "Reasoner/Query/CIsTriviallyConsistentQuery.h" #include "Reasoner/Query/CClassificationPremisingQuery.h" #include "Reasoner/Query/CComplexAnsweringQuery.h" #include "Reasoner/Query/CComplexConceptAnsweringQuery.h" #include "Reasoner/Query/CComplexAssertionsIndividualVariablesAnsweringQuery.h" #include "Reasoner/Query/CComplexAxiomsDataPropertyVariablesAnsweringQuery.h" #include "Reasoner/Kernel/Manager/Events/CJobCalculatedSatisfiableCallbackEvent.h" #include "Reasoner/Kernel/Manager/Events/CReasoningSatisfiableCalculationJobEvent.h" #include "Reasoner/Kernel/Manager/Events/CCalcQueryEvent.h" #include "Reasoner/Kernel/Manager/Events/CCalcedQueryEvent.h" #include "Reasoner/Kernel/Manager/Events/CQueriedTaxonomyComputedCallbackEvent.h" #include "Reasoner/Kernel/Manager/Events/CQueryJobCalculatedSatisfiableCallbackEvent.h" #include "Reasoner/Kernel/Manager/Events/CRequirementProcessedCallbackEvent.h" #include "Reasoner/Kernel/Manager/Events/CPrepareOntologyEvent.h" #include "Concurrent/CIntervalThread.h" #include "Concurrent/Callback/CBlockingCallbackData.h" #include "Reasoner/Kernel/Cache/COccurrenceUnsatisfiableCache.h" #include "Reasoner/Kernel/Cache/COccurrenceUnsatisfiableCacheReader.h" #include "Reasoner/Kernel/Cache/COccurrenceUnsatisfiableCacheWriter.h" #include "Reasoner/Kernel/Cache/CSignatureSatisfiableExpanderCache.h" #include "Reasoner/Kernel/Cache/CSignatureSatisfiableExpanderCacheWriter.h" #include "Reasoner/Kernel/Cache/CSignatureSatisfiableExpanderCacheReader.h" #include "Reasoner/Kernel/Cache/CReuseCompletionGraphCache.h" #include "Reasoner/Kernel/Cache/CSaturationNodeAssociatedExpansionCache.h" #include "Reasoner/Kernel/Cache/CComputedConsequencesCache.h" #include "Reasoner/Kernel/Cache/CBackendRepresentativeMemoryCache.h" #include "Reasoner/Kernel/Cache/COccurrenceStatisticsCache.h" #include "Reasoner/Classifier/CClassificationManager.h" #include "Reasoner/Classifier/CClassifiedCallbackDataContext.h" #include "Reasoner/Answerer/CAnsweringManager.h" #include "Reasoner/Answerer/CAnsweringManagerThread.h" #include "Config/CGlobalConfigurationProvider.h" #include "Config/CConfigDataReader.h" #include "Control/Command/CConfigManagerReader.h" // Logger includes #include "Logger/CLogger.h" namespace Konclude { using namespace Config; using namespace Concurrent; using namespace Callback; using namespace Scheduler; using namespace Control::Command; namespace Reasoner { using namespace Query; using namespace Classifier; using namespace Ontology; using namespace Preprocess; using namespace Consistiser; using namespace Answerer; namespace Kernel { using namespace Cache; using namespace Task; using namespace Calculation; using namespace Algorithm; namespace Manager { using namespace Events; /*! * * \class CReasonerManagerThread * \author Andreas Steigmiller * \version 0.1 * \brief TODO * */ class CReasonerManagerThread : public CReasonerManager, public CIntervalThread, public CTaskHandleAlgorithmBuilder { // public methods public: //! Constructor CReasonerManagerThread(CWatchDog *threadWatchDog = 0); //! Destructor virtual ~CReasonerManagerThread(); virtual CReasonerManager* reasoningSatisfiableCalcualtionJob(CSatisfiableCalculationJob* satCalcJob, CCallbackData* callback); virtual CJobSatisfiableResult* reasoningSatisfiableCalcualtionJob(CSatisfiableCalculationJob* satCalcJob); virtual CReasonerManager* reasoningQuery(CQuery *query, CCallbackData *callback); virtual CReasonerManager* reasoningQuery(CQuery *query); virtual CReasonerManager* prepareOntology(CConcreteOntology* ontology, const QList& reqList, CCallbackData *callback); virtual CReasonerManager* prepareOntology(CConcreteOntology* ontology, const QList& reqList); virtual COccurrenceStatisticsCache* getOccurrenceStatisticsCache(); virtual CUnsatisfiableCache *getUnsatisfiableCache(); virtual CCompletionGraphCache *getCompletionGraphCache(); virtual CBackendCache* getBackendAssociationCache(); virtual CSaturationCache* getSaturationAssociationExpansionCache(); virtual CReasonerManager *initializeManager(CConfigurationProvider *configurationProvider); virtual CTaskHandleAlgorithm *createTaskHandleAlgorithm(); virtual CCalculationManager *getCalculationManager(); virtual CPrecomputationManager* getPrecomputationManager(); virtual CPreprocessingManager* getPreprocessingManager(); virtual CRealizationManager* getRealizationManager(); // protected methods protected: virtual bool processCustomsEvents(QEvent::Type type, CCustomEvent *event); virtual void threadStarted(); virtual void threadStopped(); virtual void logQueryProgressUpdates(); virtual void readConfig(CConfigurationBase *config); virtual bool processTimer(qint64 timerID); virtual const QList getRequirementsForQuery(CQuery* query); virtual void prepareOntologyReasoning(CPrepareOntologyEvent* poe); virtual void prepareQueryReasoning(CCalcQueryEvent *cqe); virtual void initiateQueryReasoning(CQuery* query, CCallbackData* callbackData, CReasoningTaskData* reasoningData, const QList& failedRequirementList); virtual void continueRequirementProcessing(CRequirementPreparingData* reqData, CConcreteOntology* ontology); virtual void finishQueryReasoning(CCalcedQueryEvent *cqe); virtual void prepareSatisfiableBoxReasoning(CReasoningSatisfiableCalculationJobEvent *cbse); virtual void finishSatisfiableBoxReasoning(CJobCalculatedSatisfiableCallbackEvent *cbsce); virtual void finishQuerySatisfiableBoxReasoning(CQueryJobCalculatedSatisfiableCallbackEvent *cbsce); virtual void loggingCalculationStatistics(); virtual QString getLoggingCalculationStatisticsTimeSizeString(double milliseconds); virtual QString getLoggingCalculationStatisticsMemorySizeString(cint64 memSize); // protected variables protected: CWatchDog *mWatchDog; QHash mReasoningTaskDataHash; QHash mQueryCallbackHash; QHash mJobCallbackHash; QSet mProcessingRequirementsSet; QSet mCalculatingQuerySet; QSet mCalcJobSet; QSet< QPair > mProcessingStartMessageSet; QSet< QPair > mProcessingEndMessageSet; QHash mCalcQueryJobStartTimeHash; COccurrenceUnsatisfiableCache *unsatCache; CSignatureSatisfiableExpanderCache* mSatExpCache; CReuseCompletionGraphCache* mReuseCompGraphCache; CSaturationNodeAssociatedExpansionCache* mSatNodeExpCache; CComputedConsequencesCache* mCompConsCache; CBackendRepresentativeMemoryCache* mBackendAssCache; COccurrenceStatisticsCache* mOccStatsCache; static const qint64 PROGRESSQUERYTIMER = 1; CConfigurationProvider* configProvider; CClassificationManager* classificationMan; CCalculationManager* mCalculationManager; CPrecomputationManager* mPrecomputationManager; CPreprocessingManager* mPreprocessingManager; CRealizationManager* mRealizationManager; CAnsweringManager* mAnswererManager; bool mAnswererPrepared = false; QList mAnswererPreparedCallbackQueue; COntologyProcessingRequirementExpander* mRequirementExpander; cint64 mWorkControllerCount; bool mConfgAdaptThreadPoolToWorkerCount; cint64 mBlockThreadPoolThreadCount; QSemaphore mBlockThreadPoolThreadsBlockingSemaphore; QSemaphore mBlockThreadPoolThreadsReleasingSemaphore; // private methods private: bool updateBeginingCalculationStatistics(CReasoningTaskData* reaTaskData, CConfiguration* config = nullptr); bool updateFinishingCalculationStatistics(CReasoningTaskData* reaTaskData, CQueryStatistics* queryStat, CConfiguration* config = nullptr); // private variables private: }; }; // end namespace Manager }; // end namespace Kernel }; // end namespace Reasoner }; // end namespace Konclude #endif // KONCLUDE_REASONER_KERNEL_MANAGER_CREASONERMANAGERTHREAD_H