#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, bool inverted, bool allPass)
	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...

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

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

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

void	setBlocking (bool value)
	Set the CPU-blocking flag. More...

bool	isBlocking () const
	Check if algorithm is CPU-blocking. More...

bool	isOptimist () const
	Check if positive control flow decision is enforced. More...

bool	isLiar () const
	Check if control flow logic is always inverted. 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...

bool	m_inverted
	Whether the selection result is negated or not. More...

bool	m_allPass
	Whether the selection result is relevant or always "pass". More...

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

bool	m_isBlocking
	If an algorithm is CPU-blocking. 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 487 of file PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

◆ AlgorithmNode()

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

inline

Constructor.

Definition at line 490 of file PrecedenceRulesGraph.h.

         : ControlFlowNode( graph, nodeIndex, algoPtr->name() )
         , m_algorithm( algoPtr )
         , m_algoIndex( algoIndex )
         , m_algoName( algoPtr->name() )
         , m_inverted( inverted )
         , m_allPass( allPass )
         , m_isBlocking( algoPtr->isBlocking() ){};

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()

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

inline

Get algorithm index.

Definition at line 525 of file PrecedenceRulesGraph.h.

525 { return m_algoIndex; }

◆ getAlgorithm()

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

inline

get Algorithm representatives

Definition at line 523 of file PrecedenceRulesGraph.h.

523 { return m_algorithm; }

◆ getInputDataNodes()

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

inline

Get all consumer nodes.

Definition at line 515 of file PrecedenceRulesGraph.h.

515 { return m_inputs; }

◆ getOutputDataNodes()

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

inline

Get all supplier nodes.

Definition at line 513 of file PrecedenceRulesGraph.h.

513 { return m_outputs; }

◆ getParentDecisionHubs()

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

inline

Get all parent decision hubs.

Definition at line 506 of file PrecedenceRulesGraph.h.

506 { return m_parents; }

◆ getRank()

const float& concurrency::AlgorithmNode::getRank ( ) const

inline

Get Algorithm rank.

Definition at line 520 of file PrecedenceRulesGraph.h.

520 { return m_rank; }

◆ isBlocking()

bool concurrency::AlgorithmNode::isBlocking ( ) const

inline

Check if algorithm is CPU-blocking.

Definition at line 530 of file PrecedenceRulesGraph.h.

530 { return m_isBlocking; }

◆ isLiar()

bool concurrency::AlgorithmNode::isLiar ( ) const

inline

Check if control flow logic is always inverted.

Definition at line 535 of file PrecedenceRulesGraph.h.

535 { return m_inverted; };

◆ isOptimist()

bool concurrency::AlgorithmNode::isOptimist ( ) const

inline

Check if positive control flow decision is enforced.

Definition at line 533 of file PrecedenceRulesGraph.h.

533 { return m_allPass; };

◆ 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;
     }
   }

◆ setBlocking()

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

inline

Set the CPU-blocking flag.

Definition at line 528 of file PrecedenceRulesGraph.h.

528 { m_isBlocking = value; }

◆ setRank()

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

inline

Set Algorithm rank.

Definition at line 518 of file PrecedenceRulesGraph.h.

518 { m_rank = rank; }

Member Data Documentation

◆ m_algoIndex

unsigned int concurrency::AlgorithmNode::m_algoIndex

private

The index of the algorithm.

Definition at line 548 of file PrecedenceRulesGraph.h.

◆ m_algoName

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 550 of file PrecedenceRulesGraph.h.

◆ m_algorithm

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

private

Algorithm representative behind the AlgorithmNode.

Definition at line 546 of file PrecedenceRulesGraph.h.

◆ m_allPass

bool concurrency::AlgorithmNode::m_allPass

private

Whether the selection result is relevant or always "pass".

Definition at line 554 of file PrecedenceRulesGraph.h.

◆ m_inputs

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

private

Algorithm inputs (DataNodes)

Definition at line 563 of file PrecedenceRulesGraph.h.

◆ m_inverted

bool concurrency::AlgorithmNode::m_inverted

private

Whether the selection result is negated or not.

Definition at line 552 of file PrecedenceRulesGraph.h.

◆ m_isBlocking

bool concurrency::AlgorithmNode::m_isBlocking

private

If an algorithm is CPU-blocking.

Definition at line 558 of file PrecedenceRulesGraph.h.

◆ m_outputs

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

private

Algorithm outputs (DataNodes)

Definition at line 561 of file PrecedenceRulesGraph.h.

◆ m_parents

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

Control flow parents of an AlgorithmNode (DecisionNodes)

Definition at line 542 of file PrecedenceRulesGraph.h.

◆ m_rank

float concurrency::AlgorithmNode::m_rank = -1

private

Algorithm rank of any kind.

Definition at line 556 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()

◆ isBlocking()

◆ isLiar()

◆ isOptimist()

◆ printState()

◆ setBlocking()

◆ setRank()

Member Data Documentation

◆ m_algoIndex

◆ m_algoName

◆ m_algorithm

◆ m_allPass

◆ m_inputs

◆ m_inverted

◆ m_isBlocking

◆ m_outputs

◆ m_parents

◆ m_rank