ControlFlowGraph.h

Go to the documentation of this file.

#ifndef GAUDIHIVE_CONTROLFLOWGRAPH_H
#define GAUDIHIVE_CONTROLFLOWGRAPH_H

// std includes
#include <sstream>
#include <unordered_map>
#include <vector>

// local includes
#include "AlgsExecutionStates.h"

// Framework includes
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/CommonMessaging.h"

namespace concurrency
{

  namespace recursive_CF
  {

    typedef AlgsExecutionStates::State State;
    class ControlFlowGraph;

    class ControlFlowNode
    {
    public:
      ControlFlowNode( ControlFlowGraph& graph, unsigned int nodeIndex, const std::string& name )
          : m_graph( &graph ), m_nodeIndex( nodeIndex ), m_nodeName( name )
      {
      }
      virtual ~ControlFlowNode() {}
      virtual void initialize( const std::unordered_map<std::string, unsigned int>& algname_index_map ) = 0;
      virtual int updateState( AlgsExecutionStates& states, std::vector<int>& node_decisions ) const = 0;
      virtual void printState( std::stringstream& output, AlgsExecutionStates& states,
                               const std::vector<int>& node_decisions, const unsigned int& recursionLevel ) const = 0;
      const unsigned int& getNodeIndex() const { return m_nodeIndex; }
      const std::string& getNodeName() const { return m_nodeName; }

    public:
      ControlFlowGraph* m_graph;

    protected:
      std::string stateToString( const int& stateId ) const;
      unsigned int m_nodeIndex;
      std::string m_nodeName;
    };

    class DecisionNode : public ControlFlowNode
    {
    public:
      DecisionNode( ControlFlowGraph& graph, unsigned int nodeIndex, const std::string& name, bool modeConcurrent,
                    bool modePromptDecision, bool modeOR, bool allPass )
          : ControlFlowNode( graph, nodeIndex, name )
          , m_modeConcurrent( modeConcurrent )
          , m_modePromptDecision( modePromptDecision )
          , m_modeOR( modeOR )
          , m_allPass( allPass )
          , m_children()
      {
      }
      ~DecisionNode() override;
      void initialize( const std::unordered_map<std::string, unsigned int>& algname_index_map ) override;
      int updateState( AlgsExecutionStates& states, std::vector<int>& node_decisions ) const override;
      void addDaughterNode( ControlFlowNode* node );
      const std::vector<ControlFlowNode*>& getDaughters() const { return m_children; }
      void printState( std::stringstream& output, AlgsExecutionStates& states, const std::vector<int>& node_decisions,
                       const unsigned int& recursionLevel ) const override;

    public:
      bool m_modeConcurrent;
      bool m_modePromptDecision;
      bool m_modeOR;
      bool m_allPass;

    private:
      std::vector<ControlFlowNode*> m_children;
    };

    class AlgorithmNode : public ControlFlowNode
    {
    public:
      AlgorithmNode( ControlFlowGraph& graph, Algorithm* algoPtr, unsigned int nodeIndex, unsigned int algoIndex,
                     bool inverted, bool allPass )
          : ControlFlowNode( graph, nodeIndex, algoPtr->name() )
          , m_algoIndex( algoIndex )
          , m_algoName( algoPtr->name() )
          , m_inverted( inverted )
          , m_allPass( allPass )
          , m_algorithm( algoPtr ){};

      void initialize( const std::unordered_map<std::string, unsigned int>& algname_index_map ) override;
      Algorithm* getAlgorithm() const { return m_algorithm; }
      int updateState( AlgsExecutionStates& states, std::vector<int>& node_decisions ) const override;
      void printState( std::stringstream& output, AlgsExecutionStates& states, const std::vector<int>& node_decisions,
                       const unsigned int& recursionLevel ) const override;

    private:
      unsigned int m_algoIndex;
      std::string m_algoName;
      bool m_inverted;
      bool m_allPass;
      Algorithm* m_algorithm;
    };

    typedef std::unordered_map<std::string, AlgorithmNode*> AlgoNodesMap;
    typedef std::unordered_map<std::string, DecisionNode*> DecisionHubsMap;

    struct IControlFlowGraph {
      virtual ~IControlFlowGraph() = default;
    };

    class ControlFlowGraph : public CommonMessaging<IControlFlowGraph>
    {
    public:
      ControlFlowGraph( const std::string& name, SmartIF<ISvcLocator> svc ) : m_svcLocator( svc ), m_name( name ) {}
      ~ControlFlowGraph() override
      {
        if ( m_headNode != 0 ) delete m_headNode;
      }

      void initialize( const std::unordered_map<std::string, unsigned int>& algname_index_map );
      void addHeadNode( const std::string& headName, bool modeConcurrent, bool modePromptDecision, bool modeOR,
                        bool allPass );
      DecisionNode* getHeadNode() const { return m_headNode; };
      StatusCode addAlgorithmNode( Algorithm* daughterAlgo, const std::string& parentName, bool inverted,
                                   bool allPass );
      StatusCode addDecisionHubNode( Algorithm* daughterAlgo, const std::string& parentName, bool modeConcurrent,
                                     bool modePromptDecision, bool modeOR, bool allPass );
      unsigned int getControlFlowNodeCounter() const { return m_nodeCounter; }
      void updateEventState( AlgsExecutionStates& states, std::vector<int>& node_decisions ) const;
      void printState( std::stringstream& output, AlgsExecutionStates& states, const std::vector<int>& node_decisions,
                       const unsigned int& recursionLevel ) const
      {
        m_headNode->printState( output, states, node_decisions, recursionLevel );
      }
      const std::string& name() const override { return m_name; }
      SmartIF<ISvcLocator>& serviceLocator() const override { return m_svcLocator; }
      std::string dumpControlFlow() const;
      void dumpControlFlow( std::ostringstream&, ControlFlowNode*, const int& ) const;

    private:
      DecisionNode* m_headNode{nullptr};
      AlgoNodesMap m_algoNameToAlgoNodeMap;
      DecisionHubsMap m_decisionNameToDecisionHubMap;
      unsigned int m_nodeCounter{0};
      unsigned int m_algoCounter{0};
      mutable SmartIF<ISvcLocator> m_svcLocator;
      const std::string m_name;
    };

  } // namespace recursive_CF
} // namespace concurrency

#endif