ParallelHeuristicSolver.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_PARALLEL_SOLVER_H
#define HLIDAC_PES_PARALLEL_SOLVER_H

#include <atomic>
#include <map>
#include <vector>
#include "Shared/Algorithms.h"
#include "HeuristicSolver/KnowledgeBase.h"
#include "HeuristicSolver/DataStructures.h"
#include "HeuristicSolver/HeuristicAlgorithms.h"
#include "ILPSolver/RoboticLineSolverLP.h"

class ParallelHeuristicSolver {
        public:
                ParallelHeuristicSolver(const RoboticLine& l, const PrecalculatedMapping& m);
                Solution solve();
        private:
                void controlThread();
                void workerThread(uint32_t threadId, std::vector<std::vector<CircuitRecord>> initialCircuits, PrecalculatedCircuits precalculatedCircuits);

                Graph constructMinimalDurationGraph(Robot* r) const;
                DistanceMatrix<double> createInitialDistanceMatrix(const Graph& g) const;
                std::vector<CircuitRecord> generateRandomAlternatives(const uint32_t& threadId, const Graph& g, const DistanceMatrix<double>& m);
                HamiltonianCircuit<Location> getShortestCircuit(const uint32_t& threadId, const std::vector<StaticActivity*>& circuit,
                                const std::vector<Location*>& fixed, bool writeCircuit = true);
                std::vector<std::vector<CircuitRecord>> generateShortestCircuits(PrecalculatedCircuits& precalculatedCircuits);

                static double penaltyFunction(const double& minCycle, const double& demandedCycleTime);

                uint32_t selectAlternative(const std::vector<CircuitRecord>& alternatives) const;
                double calculateNewCycleTime(const uint32_t& threadId, const double& currentCycleTime, std::vector<StaticActivity*>& alternative,
                                std::vector<Location*>& fixed, Location *toFix, PrecalculatedCircuits& precalculatedCircuits);
                void addRandomTuplesToKB(const uint32_t& threadId, const uint32_t& numOfTuples,
                                std::vector<std::vector<CircuitRecord>>& initialCircuits, PrecalculatedCircuits& precalculatedCircuits);
                void generatePromisingTuples(const uint32_t& threadId);

                double changeRobotPaths(uint32_t threadId, const CircuitTuple& t, PartialSolution& ps, const std::vector<std::vector<Location*>>& fixed);

                void printProgressInfo(const double& currentRuntime);
                void writePerformanceRecordToLogFile(const double& initializationTime, const double& finalRuntime);

                double mRuntime;
                uint32_t mTabuListSize;

                std::atomic<bool> mFeasible;
                std::atomic<bool> mStopCondition;

                RoboticLine mLine;
                KnowledgeBase mKB;
                PrecalculatedMapping mMapping;
                HeuristicAlgorithms algo;

                std::vector<std::vector<std::vector<double>>> mDist;
                std::vector<std::vector<std::vector<int64_t>>> mPreds;
                std::vector<std::vector<std::vector<Location*>>> mLocs;

                std::vector<SpatialCmpTuple> mSortedSptCmp;
};

#endif