#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. More...

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

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

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

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

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

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

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

void	setRank (float rank)
	Set Algorithm rank. More...

float	getRank () const
	Get Algorithm rank. More...

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

unsigned int	getAlgoIndex () const
	Get algorithm index. More...

void	setAsynchronous (bool value)
	Set the asynchronous flag. More...

bool	isAsynchronous () const
	Check if algorithm is asynchronous. More...

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

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

virtual	~ControlFlowNode ()=default
	Destructor. More...

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

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

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

Public Attributes inherited from concurrency::ControlFlowNode
PrecedenceRulesGraph *	m_graph

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

unsigned int	m_algoIndex
	The index of the algorithm. More...

std::string	m_algoName
	The name of the algorithm. More...

float	m_rank = -1
	Algorithm rank of any kind. More...

bool	m_isAsynchronous
	If an algorithm is asynchronous. More...

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

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

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

std::string	m_nodeName

Detailed Description

Definition at line 484 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 487 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 520 of file PrecedenceRulesGraph.h.

520 { return m_algoIndex; }

◆ getAlgorithm()

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

inline

get Algorithm representatives

Definition at line 518 of file PrecedenceRulesGraph.h.

518 { return m_algorithm; }

◆ getInputDataNodes()

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

inline

Get all consumer nodes.

Definition at line 510 of file PrecedenceRulesGraph.h.

510 { return m_inputs; }

◆ getOutputDataNodes()

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

inline

Get all supplier nodes.

Definition at line 508 of file PrecedenceRulesGraph.h.

508 { return m_outputs; }

◆ getParentDecisionHubs()

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

inline

Get all parent decision hubs.

Definition at line 501 of file PrecedenceRulesGraph.h.

501 { return m_parents; }

◆ getRank()

float concurrency::AlgorithmNode::getRank ( ) const

inline

Get Algorithm rank.

Definition at line 515 of file PrecedenceRulesGraph.h.

515 { return m_rank; }

◆ isAsynchronous()

bool concurrency::AlgorithmNode::isAsynchronous ( ) const

inline

Check if algorithm is asynchronous.

Definition at line 525 of file PrecedenceRulesGraph.h.

525 { 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 523 of file PrecedenceRulesGraph.h.

523 { m_isAsynchronous = value; }

◆ setRank()

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

inline

Set Algorithm rank.

Definition at line 513 of file PrecedenceRulesGraph.h.

513 { m_rank = rank; }

Member Data Documentation

◆ m_algoIndex

unsigned int concurrency::AlgorithmNode::m_algoIndex

private

The index of the algorithm.

Definition at line 538 of file PrecedenceRulesGraph.h.

◆ m_algoName

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 540 of file PrecedenceRulesGraph.h.

◆ m_algorithm

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

private

Algorithm representative behind the AlgorithmNode.

Definition at line 536 of file PrecedenceRulesGraph.h.

◆ m_inputs

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

private

Algorithm inputs (DataNodes)

Definition at line 549 of file PrecedenceRulesGraph.h.

◆ m_isAsynchronous

bool concurrency::AlgorithmNode::m_isAsynchronous

private

If an algorithm is asynchronous.

Definition at line 544 of file PrecedenceRulesGraph.h.

◆ m_outputs

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

private

Algorithm outputs (DataNodes)

Definition at line 547 of file PrecedenceRulesGraph.h.

◆ m_parents

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

Control flow parents of an AlgorithmNode (DecisionNodes)

Definition at line 532 of file PrecedenceRulesGraph.h.

◆ m_rank

float concurrency::AlgorithmNode::m_rank = -1

private

Algorithm rank of any kind.

Definition at line 542 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