concurrency::Supervisor Class Reference

#include <src/PRGraphVisitors.h>

Inheritance diagram for concurrency::Supervisor:

Collaboration diagram for concurrency::Supervisor:

Public Member Functions
	Supervisor (EventSlot &slot, const Cause &cause, bool ifTrace=false)
	Constructor. More...
bool	visitEnter (DecisionNode &) const override
bool	visit (DecisionNode &) override
bool	visitEnter (AlgorithmNode &) const override
bool	visit (AlgorithmNode &) override
Public Member Functions inherited from concurrency::IGraphVisitor
virtual	~IGraphVisitor ()=default
virtual bool	visitEnter (DataNode &) const
virtual bool	visit (DataNode &)
virtual bool	visitEnter (ConditionNode &) const
virtual bool	visit (ConditionNode &)
virtual void	reset ()

Public Attributes
EventSlot *	m_slot
Cause	m_cause
bool	m_trace

Detailed Description

Definition at line 51 of file PRGraphVisitors.h.

Constructor & Destructor Documentation

concurrency::Supervisor::Supervisor ( EventSlot &  slot, const Cause &  cause, bool  ifTrace = false  )

inline

Constructor.

Definition at line 54 of file PRGraphVisitors.h.

        : m_slot( &slot ), m_cause( cause ), m_trace( ifTrace ){};

Member Function Documentation

bool concurrency::Supervisor::visit ( DecisionNode &  node )

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 168 of file PRGraphVisitors.cpp.

                                             {

    bool foundNonResolvedChild = false;
    bool foundNegativeChild    = false;
    bool foundPositiveChild    = false;
    int  decision              = -1;

    // Leave a sub-slot if this is the exit node
    EventSlot* oldSlot = nullptr;
    if ( m_slot->parentSlot && m_slot->entryPoint == node.getNodeName() ) {
      oldSlot = m_slot;
      m_slot  = m_slot->parentSlot;
    }

    // If children are in sub-slots, loop over all
    auto searchResult = m_slot->subSlotsByNode.find( node.getNodeName() );
    if ( searchResult != m_slot->subSlotsByNode.end() ) {
      bool breakout = false;
      for ( unsigned int slotIndex : searchResult->second ) {

        // Enter the sub-slot
        m_slot = &( m_slot->allSubSlots[slotIndex] );

        for ( auto child : node.getDaughters() ) {

          int& childDecision = m_slot->controlFlowState[child->getNodeIndex()];

          if ( childDecision == -1 )
            foundNonResolvedChild = true;
          else if ( childDecision == 1 )
            foundPositiveChild = true;
          else
            foundNegativeChild = true;

          if ( node.m_modePromptDecision ) {
            if ( node.m_modeOR && foundPositiveChild ) {
              decision = 1;
              breakout = true;
              break;
            } else if ( !node.m_modeOR && foundNegativeChild ) {
              decision = 0;
              breakout = true;
              break;
            }
          } else {
            if ( foundNonResolvedChild ) {
              breakout = true;
              break;
            }
          }
        }

        // Leave the sub-slot
        m_slot = m_slot->parentSlot;
        if ( breakout ) break;
      }
    } else {
      for ( auto child : node.getDaughters() ) {
        int& childDecision = m_slot->controlFlowState[child->getNodeIndex()];

        if ( childDecision == -1 )
          foundNonResolvedChild = true;
        else if ( childDecision == 1 )
          foundPositiveChild = true;
        else
          foundNegativeChild = true;

        if ( node.m_modePromptDecision ) {
          if ( node.m_modeOR && foundPositiveChild ) {
            decision = 1;
            break;
          } else if ( !node.m_modeOR && foundNegativeChild ) {
            decision = 0;
            break;
          }
        } else {
          if ( foundNonResolvedChild ) break;
        }
      }
    } // end monitoring children

    if ( !foundNonResolvedChild && decision == -1 ) {
      if ( node.m_modeOR ) { // OR
        if ( foundPositiveChild )
          decision = 1;
        else
          decision = 0;
      } else { // AND
        if ( foundNegativeChild )
          decision = 0;
        else
          decision = 1;
      }
    }

    if ( node.m_inverted && decision == 1 )
      decision = 0;
    else if ( node.m_inverted && decision == 0 )
      decision = 1;

    if ( node.m_allPass && !foundNonResolvedChild ) decision = 1;

    if ( decision != -1 ) {
      m_slot->controlFlowState[node.getNodeIndex()] = decision;

      // if a decision was made for this node, propagate the result upwards
      for ( auto parent : node.m_parents ) { parent->accept( *this ); }

      if ( oldSlot ) m_slot = oldSlot;
      return true;
    }

    // if no decision can be made yet, request further information downwards
    // Enter subslots for children if needed
    if ( searchResult != m_slot->subSlotsByNode.end() ) {
      for ( unsigned int slotIndex : searchResult->second ) {

        // Enter sub-slot
        m_slot = &( m_slot->allSubSlots[slotIndex] );

        for ( auto child : node.getDaughters() ) {
          bool result = child->accept( *this );
          if ( !node.m_modeConcurrent )
            if ( result ) break; // stop on first unresolved child if its decision hub is sequential
        }

        // Leave sub-slot
        m_slot = m_slot->parentSlot;
      }
    } else {
      for ( auto child : node.getDaughters() ) {
        bool result = child->accept( *this );
        if ( !node.m_modeConcurrent )
          if ( result ) break; // stop on first unresolved child if its decision hub is sequential
      }
    }

    if ( oldSlot ) m_slot = oldSlot;
    return false;
  }

bool concurrency::Supervisor::visit ( AlgorithmNode &  node )

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 317 of file PRGraphVisitors.cpp.

                                              {

    bool result = false;

    auto& states = m_slot->algsStates;
    auto& state  = states[node.getAlgoIndex()];

    // Promote with INITIAL->CR
    if ( AState::INITIAL == state ) states.set( node.getAlgoIndex(), AState::CONTROLREADY ).ignore();

    // Try to promote with CR->DR
    if ( AState::CONTROLREADY == state ) {
      auto promoter = DataReadyPromoter( *m_slot, m_cause, m_trace );
      result        = promoter.visit( node );
    } else {
      result = true;
    }

    // return true only when an algorithm is not lower than DR in its FSM
    // i.e., the visitor has done everything it could with this algorithm
    return result;
  }

bool concurrency::Supervisor::visitEnter ( DecisionNode &  node ) const

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 134 of file PRGraphVisitors.cpp.

                                                        {
    // Protect against graph traversal escaping from sub-slots
    if ( m_slot->parentSlot ) {
      // Examine the ancestry of this node, looking for sub-slot entry point
      bool                      canFindExit = false;
      std::queue<DecisionNode*> allAncestors;
      allAncestors.push( &node );
      while ( allAncestors.size() ) {

        DecisionNode* thisAncestor = allAncestors.front();
        allAncestors.pop();

        if ( thisAncestor->getNodeName() == m_slot->entryPoint ) {

          // This ancestor is the sub-slot exit
          canFindExit = true;
          break;

        } else {

          // Go further up the node ancestry
          for ( auto& evenOlder : thisAncestor->m_parents ) { allAncestors.push( evenOlder ); }
        }
      }

      // If the sub-slot entry point is not in this node's ancestry, don't visit the node
      if ( !canFindExit ) return false;
    }

    if ( m_slot->controlFlowState[node.getNodeIndex()] != -1 ) return false;
    return true;
  }

bool concurrency::Supervisor::visitEnter ( AlgorithmNode &  node ) const

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 310 of file PRGraphVisitors.cpp.

                                                         {

    if ( m_slot->controlFlowState[node.getNodeIndex()] != -1 ) return false;
    return true;
  }

Member Data Documentation

Cause concurrency::Supervisor::m_cause

Definition at line 69 of file PRGraphVisitors.h.

EventSlot* concurrency::Supervisor::m_slot

Definition at line 68 of file PRGraphVisitors.h.

bool concurrency::Supervisor::m_trace

Definition at line 70 of file PRGraphVisitors.h.

---

The documentation for this class was generated from the following files:

• GaudiHive/src/PRGraphVisitors.h
• GaudiHive/src/PRGraphVisitors.cpp