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

Inheritance diagram for concurrency::AlgorithmNode:

Collaboration diagram for concurrency::AlgorithmNode:

[legend]

Public Member Functions
	AlgorithmNode (PrecedenceRulesGraph &graph, Gaudi::Algorithm *algoPtr, unsigned int nodeIndex, unsigned int algoIndex)
	Constructor.

bool	accept (IGraphVisitor &visitor) override
	Visitor entry point.

void	addParentNode (DecisionNode *node)
	Add a parent node.

const std::vector< DecisionNode * > &	getParentDecisionHubs () const
	Get all parent decision hubs.

void	addOutputDataNode (DataNode *node)
	Associate an AlgorithmNode, which is a data supplier for this one.

void	addInputDataNode (DataNode *node)
	Associate an AlgorithmNode, which is a data consumer of this one.

const std::vector< DataNode * > &	getOutputDataNodes () const
	Get all supplier nodes.

const std::vector< DataNode * > &	getInputDataNodes () const
	Get all consumer nodes.

void	setRank (float rank)
	Set Algorithm rank.

float	getRank () const
	Get Algorithm rank.

Gaudi::Algorithm *	getAlgorithm () const
	get Algorithm representatives

unsigned int	getAlgoIndex () const
	Get algorithm index.

void	setAsynchronous (bool value)
	Set the asynchronous flag.

bool	isAsynchronous () const
	Check if algorithm is asynchronous.

void	printState (std::stringstream &output, EventSlot &slot, const unsigned int &recursionLevel) const override
	Print a string representing the control flow state.

Public Member Functions inherited from concurrency::ControlFlowNode
	ControlFlowNode (PrecedenceRulesGraph &graph, unsigned int nodeIndex, const std::string &name)
	Constructor.

virtual	~ControlFlowNode ()=default
	Destructor.

const unsigned int &	getNodeIndex () const
	Get node index.

const std::string &	name () const
	Get node name.

Public Attributes
std::vector< DecisionNode * >	m_parents
	Control flow parents of an AlgorithmNode (DecisionNodes)

Public Attributes inherited from concurrency::ControlFlowNode
PrecedenceRulesGraph *	m_graph

Private Attributes
Gaudi::Algorithm *	m_algorithm
	Algorithm representative behind the AlgorithmNode.

unsigned int	m_algoIndex
	The index of the algorithm.

std::string	m_algoName
	The name of the algorithm.

float	m_rank = -1
	Algorithm rank of any kind.

bool	m_isAsynchronous
	If an algorithm is asynchronous.

std::vector< DataNode * >	m_outputs
	Algorithm outputs (DataNodes)

std::vector< DataNode * >	m_inputs
	Algorithm inputs (DataNodes)

Additional Inherited Members
Protected Attributes inherited from concurrency::ControlFlowNode
unsigned int	m_nodeIndex

std::string	m_nodeName

Detailed Description

Definition at line 485 of file PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

◆ AlgorithmNode()

concurrency::AlgorithmNode::AlgorithmNode	(	PrecedenceRulesGraph &	graph,
		Gaudi::Algorithm *	algoPtr,
		unsigned int	nodeIndex,
		unsigned int	algoIndex )

inline

Constructor.

Definition at line 488 of file PrecedenceRulesGraph.h.

        : ControlFlowNode( graph, nodeIndex, algoPtr->name() )
        , m_algorithm( algoPtr )
        , m_algoIndex( algoIndex )
        , m_algoName( algoPtr->name() )
        , m_isAsynchronous( algoPtr->isAsynchronous() ) {}

Member Function Documentation

◆ accept()

bool concurrency::AlgorithmNode::accept ( IGraphVisitor & visitor )

overridevirtual

Visitor entry point.

Implements concurrency::ControlFlowNode.

Definition at line 191 of file PrecedenceRulesGraph.cpp.

                                                     {
 
    if ( visitor.visitEnter( *this ) ) {
      visitor.visit( *this );
      return true; // visitor was accepted to promote the algorithm
    }
 
    return false; // visitor was rejected (since the algorithm already produced a decision)
  }

◆ addInputDataNode()

void concurrency::AlgorithmNode::addInputDataNode ( DataNode * node )

Associate an AlgorithmNode, which is a data consumer of this one.

Definition at line 214 of file PrecedenceRulesGraph.cpp.

                                                       {
 
    if ( std::find( m_inputs.begin(), m_inputs.end(), node ) == m_inputs.end() ) m_inputs.push_back( node );
  }

◆ addOutputDataNode()

void concurrency::AlgorithmNode::addOutputDataNode ( DataNode * node )

Associate an AlgorithmNode, which is a data supplier for this one.

Definition at line 208 of file PrecedenceRulesGraph.cpp.

                                                        {
 
    if ( std::find( m_outputs.begin(), m_outputs.end(), node ) == m_outputs.end() ) m_outputs.push_back( node );
  }

◆ addParentNode()

void concurrency::AlgorithmNode::addParentNode ( DecisionNode * node )

Add a parent node.

Definition at line 202 of file PrecedenceRulesGraph.cpp.

                                                        {
 
    if ( std::find( m_parents.begin(), m_parents.end(), node ) == m_parents.end() ) m_parents.push_back( node );
  }

◆ getAlgoIndex()

unsigned int concurrency::AlgorithmNode::getAlgoIndex ( ) const

inline

Get algorithm index.

Definition at line 521 of file PrecedenceRulesGraph.h.

521{ return m_algoIndex; }

◆ getAlgorithm()

Gaudi::Algorithm * concurrency::AlgorithmNode::getAlgorithm ( ) const

inline

get Algorithm representatives

Definition at line 519 of file PrecedenceRulesGraph.h.

519{ return m_algorithm; }

◆ getInputDataNodes()

const std::vector< DataNode * > & concurrency::AlgorithmNode::getInputDataNodes ( ) const

inline

Get all consumer nodes.

Definition at line 511 of file PrecedenceRulesGraph.h.

511{ return m_inputs; }

◆ getOutputDataNodes()

const std::vector< DataNode * > & concurrency::AlgorithmNode::getOutputDataNodes ( ) const

inline

Get all supplier nodes.

Definition at line 509 of file PrecedenceRulesGraph.h.

509{ return m_outputs; }

◆ getParentDecisionHubs()

const std::vector< DecisionNode * > & concurrency::AlgorithmNode::getParentDecisionHubs ( ) const

inline

Get all parent decision hubs.

Definition at line 502 of file PrecedenceRulesGraph.h.

502{ return m_parents; }

◆ getRank()

float concurrency::AlgorithmNode::getRank ( ) const

inline

Get Algorithm rank.

Definition at line 516 of file PrecedenceRulesGraph.h.

516{ return m_rank; }

concurrency::AlgorithmNode::m_rank

float m_rank

Algorithm rank of any kind.

Definition PrecedenceRulesGraph.h:543

◆ isAsynchronous()

bool concurrency::AlgorithmNode::isAsynchronous ( ) const

inline

Check if algorithm is asynchronous.

Definition at line 526 of file PrecedenceRulesGraph.h.

526{ return m_isAsynchronous; }

◆ printState()

void concurrency::AlgorithmNode::printState	(	std::stringstream &	output,
		EventSlot &	slot,
		const unsigned int &	recursionLevel ) const

overridevirtual

Print a string representing the control flow state.

Implements concurrency::ControlFlowNode.

Definition at line 77 of file PrecedenceRulesGraph.cpp.

                                                                             {
 
    auto&       node_decisions = slot.controlFlowState;
    auto&       states         = slot.algsStates;
    std::string indent( recursionLevel, ' ' );
    output << indent << m_nodeName << " (" << m_nodeIndex << ")"
           << ", w/ decision: " << stateToString( node_decisions[m_nodeIndex] ) << "(" << node_decisions[m_nodeIndex]
           << ")"
           << ", in state: " << states[m_algoIndex] << std::endl;
 
    // In a stall, CONTROLREADY nodes are interesting
    if ( states[m_algoIndex] == AlgsExecutionStates::State::CONTROLREADY ) {
 
      // Check all data dependencies
      output << indent << "========" << std::endl;
      for ( auto dataNode : this->getInputDataNodes() ) {
 
        // Was the data produced?
        ConditionNode*    conditionNode = dynamic_cast<ConditionNode*>( dataNode );
        DataReadyPromoter visitor( slot, {} );
        bool              wasProduced = false;
        if ( conditionNode ) {
          // ConditionNodes always request data on visit()
          // Instead take the opposite of visitEnter(), since you may not enter if it already exists
          wasProduced = !visitor.visitEnter( *conditionNode );
        } else {
          // For DataNodes, the check is done in visit()
          wasProduced = visitor.visit( *dataNode );
        }
 
        // Print out states of producer algs if data is missing
        if ( !wasProduced ) {
 
          // Say if it's conditions data or not
          if ( conditionNode )
            output << indent << "missing conditions data: " << dataNode->name() << std::endl;
          else
            output << indent << "missing data: " << dataNode->name() << std::endl;
 
          // Find out if the algorithm needs it because of a tool
          DataHandleFinder finder( dataNode->name() );
          this->getAlgorithm()->acceptDHVisitor( &finder );
          if ( finder.holderNames().size() > 1 ) {
            output << indent << "required by tool:";
            for ( auto const& holderName : finder.holderNames() ) {
              if ( holderName != this->name() ) output << " " << holderName;
            }
            output << std::endl;
          }
 
          if ( conditionNode ) {
            // State which IOVs the data exists for
            output << indent << "current EventID: " << EventIDBase( slot.eventContext->eventID() ) << std::endl;
            std::vector<EventIDRange> validRanges;
            conditionNode->m_condSvc->validRanges( validRanges, dataNode->name() )
                .ignore( /* AUTOMATICALLY ADDED FOR gaudi/Gaudi!763 */ );
            for ( auto& range : validRanges ) { output << indent << "interval of validity: " << range << std::endl; }
            if ( validRanges.empty() ) output << indent << "no interval(s) of validity" << std::endl;
          } else {
            // State which algs produce this data
            output << indent << "can be produced by alg(s): ";
            for ( auto algoNode : dataNode->getProducers() ) {
              output << "( " << algoNode->name() << " in state: " << states[algoNode->getAlgoIndex()] << " ) ";
            }
            output << std::endl;
          }
 
          // See where data is available (ignore conditions, since these are top-level)
          if ( !conditionNode ) {
            std::vector<EventSlot>* testSubSlots = &slot.allSubSlots;
            auto*                   subSlotMap   = &slot.subSlotsByNode;
 
            // Examine the top-level slot if you did not start there
            if ( slot.parentSlot ) {
              visitor.m_slot = slot.parentSlot;
              testSubSlots   = &slot.parentSlot->allSubSlots;
              subSlotMap     = &slot.parentSlot->subSlotsByNode;
              if ( visitor.visit( *dataNode ) ) {
                output << indent << "data is available at whole-event level" << std::endl;
              }
            }
 
            // Examine all sub slots, grouped by entry point
            for ( auto& pair : *subSlotMap ) {
              if ( pair.second.size() > 0 ) {
                bool madeLine = false;
 
                // Loop over the slots for this entry point
                for ( int slotIndex : pair.second ) {
 
                  EventSlot* subSlot = &testSubSlots->at( slotIndex );
                  visitor.m_slot     = subSlot;
                  if ( visitor.visit( *dataNode ) ) {
 
                    if ( !madeLine ) {
                      // Only mention this set of sub-slots at all if one has the data
                      output << indent << "data is available in sub-slot(s) ";
                      madeLine = true;
                    }
                    output << slotIndex << ", ";
                  }
                }
                if ( madeLine ) { output << "entered from " << pair.first << std::endl; }
              }
            }
          }
        }
      }
      output << indent << "========" << std::endl;
    }
  }

◆ setAsynchronous()

void concurrency::AlgorithmNode::setAsynchronous ( bool value )

inline

Set the asynchronous flag.

Definition at line 524 of file PrecedenceRulesGraph.h.

524{ m_isAsynchronous = value; }

◆ setRank()

void concurrency::AlgorithmNode::setRank ( float rank )

inline

Set Algorithm rank.

Definition at line 514 of file PrecedenceRulesGraph.h.

514{ m_rank = rank; }

Member Data Documentation

◆ m_algoIndex

unsigned int concurrency::AlgorithmNode::m_algoIndex

private

The index of the algorithm.

Definition at line 539 of file PrecedenceRulesGraph.h.

◆ m_algoName

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 541 of file PrecedenceRulesGraph.h.

◆ m_algorithm

Gaudi::Algorithm* concurrency::AlgorithmNode::m_algorithm

private

Algorithm representative behind the AlgorithmNode.

Definition at line 537 of file PrecedenceRulesGraph.h.

◆ m_inputs

std::vector<DataNode*> concurrency::AlgorithmNode::m_inputs

private

Algorithm inputs (DataNodes)

Definition at line 550 of file PrecedenceRulesGraph.h.

◆ m_isAsynchronous

bool concurrency::AlgorithmNode::m_isAsynchronous

private

If an algorithm is asynchronous.

Definition at line 545 of file PrecedenceRulesGraph.h.

◆ m_outputs

std::vector<DataNode*> concurrency::AlgorithmNode::m_outputs

private

Algorithm outputs (DataNodes)

Definition at line 548 of file PrecedenceRulesGraph.h.

◆ m_parents

std::vector<DecisionNode*> concurrency::AlgorithmNode::m_parents

Control flow parents of an AlgorithmNode (DecisionNodes)

Definition at line 533 of file PrecedenceRulesGraph.h.

◆ m_rank

float concurrency::AlgorithmNode::m_rank = -1

private

Algorithm rank of any kind.

Definition at line 543 of file PrecedenceRulesGraph.h.

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

GaudiHive/src/PRGraph/PrecedenceRulesGraph.h
GaudiHive/src/PRGraph/PrecedenceRulesGraph.cpp

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AlgorithmNode()

Member Function Documentation

◆ accept()

◆ addInputDataNode()

◆ addOutputDataNode()

◆ addParentNode()

◆ getAlgoIndex()

◆ getAlgorithm()

◆ getInputDataNodes()

◆ getOutputDataNodes()

◆ getParentDecisionHubs()

◆ getRank()

◆ isAsynchronous()

◆ printState()

◆ setAsynchronous()

◆ setRank()

Member Data Documentation

◆ m_algoIndex

◆ m_algoName

◆ m_algorithm

◆ m_inputs

◆ m_isAsynchronous

◆ m_outputs

◆ m_parents

◆ m_rank