ExplorationThread.h

 
#ifndef STAMINA_BUILDER_THREADS_EXPLORATIONTHREAD_H
#define STAMINA_BUILDER_THREADS_EXPLORATIONTHREAD_H
 
#include "BaseThread.h"
#include "ControlThread.h"
 
#include "util/StateIndexArray.h"
#include "builder/ProbabilityState.h"
 
namespace stamina {
    namespace builder {
        namespace threads {
 
            template <typename StateType, typename RewardModelType, typename ValueType>
            class ExplorationThread : public BaseThread<StateType, RewardModelType, ValueType> {
            public:
//              typedef std::pair<CompressedState &, std::shared_ptr<StaminaModelBuilder<ValueType, RewardModelType, StateType>>> StateAndProbability;
                struct StateAndProbability {
                    CompressedState & state;
                    StateType index;
                    double deltaPi;
                };
 
                struct StateIndexAndThread {
                    CompressedState & state;
                    StateType index;
                    uint8_t threadIndex;
                };
                ExplorationThread(
                    StaminaModelBuilder<ValueType, RewardModelType, StateType> * parent
                    , uint8_t threadIndex
                    , ControlThread<StateType, RewardModelType, ValueType> & controlThread
                    , uint32_t stateSize
                    , util::StateIndexArray<StateType, ProbabilityState<StateType>> * stateMap
                    , std::shared_ptr<storm::generator::PrismNextStateGenerator<ValueType, StateType>> const& generator
                    , std::function<StateType (CompressedState const&)> stateToIdCallback
                );
                uint8_t getIndex();
                uint32_t getNumberOfOwnedStates();
                bool isIdling();
                void setIsCtmc(bool isCtmc);
                void requestCrossExploration(CompressedState & state, double deltaPi);
                void requestCrossExploration(StateType stateIndex, double deltaPi);
                virtual void mainLoop() override; // doExploration
            protected:
                virtual void exploreStates() = 0;
                virtual void exploreState(StateAndProbability & stateProbability) = 0;
                virtual void enqueueSuccessors(CompressedState & state) = 0; // stateToIdCallback
                // Weak priority on crossExplorationQueue (superseded by mutex lock)
                std::shared_mutex crossExplorationQueueMutex;
                std::deque<std::pair<CompressedState, double>> crossExplorationQueue;
                std::deque<StateAndProbability> mainExplorationQueue;
                uint32_t numberOfOwnedStates;
                bool idling;
                ControlThread<StateType, RewardModelType, ValueType> & controlThread;
                util::StateIndexArray<StateType, ProbabilityState<StateType>> * stateMap;
                storm::storage::sparse::StateStorage<StateType> & stateStorage;
                std::shared_ptr<storm::generator::PrismNextStateGenerator<ValueType, StateType>> const& generator;
                std::deque<StateAndProbability> statesTerminatedLastIteration;
                std::function<StateType (CompressedState const&)> stateToIdCallback;
                // The states we should request cross exploration from
                std::deque<StateIndexAndThread> statesToRequestCrossExploration;
            private:
                const uint8_t threadIndex;
            };
        } // namespace threads
    } // namespace builder
} // namespace stamina
 
#endif // STAMINA_BUILDER_THREADS_EXPLORATIONTHREAD_H