concurrency::Supervisor Class Reference

#include </builds/gaudi/Gaudi/GaudiHive/src/PRGraph/Visitors/Promoters.h>

Inheritance diagram for concurrency::Supervisor:

Collaboration diagram for concurrency::Supervisor:

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

Public Attributes
EventSlot *	m_slot
Cause	m_cause
bool	m_trace

Detailed Description

Definition at line 63 of file Promoters.h.

Constructor & Destructor Documentation

Supervisor()

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

inline

Constructor.

Definition at line 66 of file Promoters.h.

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

Member Function Documentation

visit() [1/4]

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

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 330 of file Promoters.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;
  }

visit() [2/4]

virtual bool concurrency::IGraphVisitor::visit ( ConditionNode & )

inlinevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 34 of file IGraphVisitor.h.

{ return true; }

visit() [3/4]

virtual bool concurrency::IGraphVisitor::visit ( DataNode & )

inlinevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 31 of file IGraphVisitor.h.

{ return true; }

visit() [4/4]

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

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 159 of file Promoters.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.name() ) {
      oldSlot = m_slot;
      m_slot  = m_slot->parentSlot;
    }
 
    // If children are in sub-slots, loop over all
    auto searchResult = m_slot->subSlotsByNode.find( node.name() );
    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;
 
      // propagate aggregated decision upward to active regions of the graph
      if ( node.m_parents.size() == 1 ) {
        node.m_parents[0]->accept( *this );
      } else if ( m_slot->parentSlot ) {
        auto scout = SubSlotScout( m_slot, node );
        for ( auto& p : node.m_parents ) {
          p->accept( scout );
          if ( scout.reply() ) p->accept( *this );
          scout.reset();
        }
      } else {
        auto scout = ActiveLineageScout( m_slot, node );
        for ( auto& p : node.m_parents ) {
          p->accept( scout );
          if ( scout.reply() ) p->accept( *this );
          scout.reset();
        }
      }
 
      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
 
          // Check that this node may stil be evaluated
          if ( node.m_modePromptDecision && m_slot->controlFlowState[node.getNodeIndex()] > -1 ) break;
        }
 
        // 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
 
        // Check that this node may stil be evaluated
        if ( node.m_modePromptDecision && m_slot->controlFlowState[node.getNodeIndex()] > -1 ) break;
      }
    }
 
    if ( oldSlot ) m_slot = oldSlot;
    return false;
  }

visitEnter() [1/4]

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

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 323 of file Promoters.cpp.

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

visitEnter() [2/4]

virtual bool concurrency::IGraphVisitor::visitEnter ( ConditionNode & ) const

inlinevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 33 of file IGraphVisitor.h.

{ return true; }

visitEnter() [3/4]

virtual bool concurrency::IGraphVisitor::visitEnter ( DataNode & ) const

inlinevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 30 of file IGraphVisitor.h.

{ return true; }

visitEnter() [4/4]

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

overridevirtual

Reimplemented from concurrency::IGraphVisitor.

Definition at line 152 of file Promoters.cpp.

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

Member Data Documentation

m_cause

Cause concurrency::Supervisor::m_cause

Definition at line 81 of file Promoters.h.

m_slot

EventSlot* concurrency::Supervisor::m_slot

Definition at line 80 of file Promoters.h.

m_trace

bool concurrency::Supervisor::m_trace

Definition at line 82 of file Promoters.h.

---

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

• GaudiHive/src/PRGraph/Visitors/Promoters.h
• GaudiHive/src/PRGraph/Visitors/Promoters.cpp