concurrency::AlgorithmNode Class Reference

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

Inheritance diagram for concurrency::AlgorithmNode:

Collaboration diagram for concurrency::AlgorithmNode:

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...
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...
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_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 482 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 485 of file PrecedenceRulesGraph.h.

        : ControlFlowNode( graph, nodeIndex, algoPtr->name() )
        , m_algorithm( algoPtr )
        , m_algoIndex( algoIndex )
        , m_algoName( algoPtr->name() )
        , 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 518 of file PrecedenceRulesGraph.h.

{ return m_algoIndex; }

getAlgorithm()

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

inline

get Algorithm representatives

Definition at line 516 of file PrecedenceRulesGraph.h.

{ return m_algorithm; }

getInputDataNodes()

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

inline

Get all consumer nodes.

Definition at line 508 of file PrecedenceRulesGraph.h.

{ return m_inputs; }

getOutputDataNodes()

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

inline

Get all supplier nodes.

Definition at line 506 of file PrecedenceRulesGraph.h.

{ return m_outputs; }

getParentDecisionHubs()

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

inline

Get all parent decision hubs.

Definition at line 499 of file PrecedenceRulesGraph.h.

{ return m_parents; }

getRank()

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

inline

Get Algorithm rank.

Definition at line 513 of file PrecedenceRulesGraph.h.

{ return m_rank; }

isBlocking()

bool concurrency::AlgorithmNode::isBlocking ( ) const

inline

Check if algorithm is CPU-blocking.

Definition at line 523 of file PrecedenceRulesGraph.h.

{ return m_isBlocking; }

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 521 of file PrecedenceRulesGraph.h.

{ m_isBlocking = value; }

setRank()

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

inline

Set Algorithm rank.

Definition at line 511 of file PrecedenceRulesGraph.h.

{ m_rank = rank; }

Member Data Documentation

m_algoIndex

unsigned int concurrency::AlgorithmNode::m_algoIndex

private

The index of the algorithm.

Definition at line 536 of file PrecedenceRulesGraph.h.

m_algoName

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 538 of file PrecedenceRulesGraph.h.

m_algorithm

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

private

Algorithm representative behind the AlgorithmNode.

Definition at line 534 of file PrecedenceRulesGraph.h.

m_inputs

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

private

Algorithm inputs (DataNodes)

Definition at line 547 of file PrecedenceRulesGraph.h.

m_isBlocking

bool concurrency::AlgorithmNode::m_isBlocking

private

If an algorithm is CPU-blocking.

Definition at line 542 of file PrecedenceRulesGraph.h.

m_outputs

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

private

Algorithm outputs (DataNodes)

Definition at line 545 of file PrecedenceRulesGraph.h.

m_parents

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

Control flow parents of an AlgorithmNode (DecisionNodes)

Definition at line 530 of file PrecedenceRulesGraph.h.

m_rank

float concurrency::AlgorithmNode::m_rank = -1

private

Algorithm rank of any kind.

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