KnowledgeBase.h

Go to the documentation of this file.

/*
        This file is part of the EnergyOptimizatorOfRoboticCells program.

        EnergyOptimizatorOfRoboticCells is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        EnergyOptimizatorOfRoboticCells 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 General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with EnergyOptimizatorOfRoboticCells. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef HLIDAC_PES_KNOWLEDGE_BASE_H
#define HLIDAC_PES_KNOWLEDGE_BASE_H

#include <algorithm>
#include <atomic>
#include <cassert>
#include <list>
#include <mutex>
#include <queue>
#include <set>
#include <vector>
#include <utility>
#include "RoboticLine.h"
#include "Solution/Solution.h"
#include "Shared/PrecalculatedMapping.h"
#include "HeuristicSolver/DataStructures.h"

class KnowledgeBase {
        public:
                KnowledgeBase();

                std::list<std::pair<Solution, CircuitTuple>> eliteSolutions();
                Solution bestSolution();
                void candidate(const Solution& s, const CircuitTuple& t);

                void addTuple(CircuitTuple&& t);
                void addErrorMessage(const std::string& msg);
                std::vector<std::string> errorMessages() const { return mErrorMessages; }
                CircuitTuple getTuple();

                void reportInfDueToLP() { ++mInfDueToLP; }
                uint64_t numberOfLPBreaks() const { return mInfDueToLP; }
                void reportInfDueToLocHeur() { ++mInfDueToLocHeur; }
                uint64_t numberOfLocHeurBreaks() const { return mInfDueToLocHeur; }
                void reportInfDueToPwrmHeur() { ++mInfDueToPwrmHeur; }
                uint64_t numberOfPwrmHeurBreaks() const { return mInfDueToPwrmHeur; }
                void reportInfDueToPathChange() { ++mInfDueToChangedPath; }
                uint64_t numberOfChangePathBreaks() const { return mInfDueToChangedPath; }

                void recordInfeasibleLP();
                double infeasibilityRate();
                void recordLPCall(double runtime);
                std::pair<uint64_t, double> infoLP();
                void recordLPFixDeterioration(double deterioration);
                double averageLPFixDeterioration();
                double averageNumberOfLPCallsForLPFix();
                void recordPartialProblemSolveCall();

                void recordLocHeurCall(double runtime);
                std::pair<uint64_t, double> infoLocHeur();
                void recordLocHeurRelErr(double relativeEstError);
                double averageErrOfLocHeur();

                void recordPwrmHeurCall(double runtime);
                std::pair<uint64_t, double> infoPwrmHeur();
                void recordPwrmHeurRelErr(double relativeEstError);
                double averageErrOfPwrmHeur();

                void recordChangePathCall() { ++mPathChangeCalls; }
                uint64_t pathChangeCalls() const { return mPathChangeCalls; }

                void recordAddTuplesCall(double runtime);
                std::pair<uint64_t, double> infoTuplesGeneration();
                void recordNumberOfItersPerTuple(uint64_t iters);
                std::pair<uint64_t, double> infoItersPerTuple();
                double percentageOfProcessed();
        private:

                template <class T>
                void record(T value, T& addTo);

                template <class T>
                void record(T value, T& addTo, std::atomic<uint64_t>& counter);

                std::pair<uint64_t, double> getInfo(double& aggregatedValue, std::atomic<uint64_t>& counter);

                std::queue<CircuitTuple> mTuples;
                std::vector<std::string> mErrorMessages;
                std::list<std::pair<Solution, CircuitTuple>> mEliteSolutions;

                std::atomic<uint64_t> mAddedTuples;
                std::atomic<uint64_t> mProcessedTuples;
                std::atomic<uint64_t> mOptimizationPhaseCounter;

                std::atomic<uint64_t> mInfDueToLP;
                std::atomic<uint64_t> mInfDueToLocHeur;
                std::atomic<uint64_t> mInfDueToPwrmHeur;
                std::atomic<uint64_t> mInfDueToChangedPath;
                std::atomic<uint64_t> mInfeasibleCounter;

                std::atomic<uint64_t> mLPCalls;
                std::atomic<uint64_t> mLPFixCalls;
                std::atomic<uint64_t> mPartProbCalls;
                std::atomic<uint64_t> mLocHeurCalls;
                std::atomic<uint64_t> mPwrmHeurCalls;
                std::atomic<uint64_t> mPathChangeCalls;
                std::atomic<uint64_t> mSumOfIters;

                double mLPTime;
                double mLocHeurTime;
                double mPwrmHeurTime;
                double mTupleGenTime;
                double mSumOfDeteriorations;
                double mSumOfLocHeurErrs;
                double mSumOfPwrmHeurErrs;

                std::mutex mEliteMtx;
                std::mutex mTuplesMtx;
                std::mutex mErrorsMtx;
                std::mutex mStatMtx;
};

#endif