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

Inheritance diagram for concurrency::PrecedenceRulesGraph:

Collaboration diagram for concurrency::PrecedenceRulesGraph:

[legend]

Public Member Functions
	PrecedenceRulesGraph (const std::string &name, SmartIF< ISvcLocator > svc)
	Constructor. More...

StatusCode	initialize ()
	Initialize graph. More...

void	accept (IGraphVisitor &visitor) const
	An entry point to visit all graph nodes. More...

StatusCode	addDataNode (const DataObjID &dataPath)
	Add DataNode that represents DataObject. More...

DataNode *	getDataNode (const DataObjID &dataPath) const
	Get DataNode by DataObject path using graph index. More...

void	registerIODataObjects (const Gaudi::Algorithm *algo)
	Register algorithm in the Data Dependency index. More...

StatusCode	buildDataDependenciesRealm ()
	Build data dependency realm WITH data object nodes participating. More...

void	addHeadNode (const std::string &headName, concurrency::Concurrent, concurrency::PromptDecision, concurrency::ModeOr, concurrency::AllPass, concurrency::Inverted)
	Add a node, which has no parents. More...

DecisionNode *	getHeadNode () const
	Get head node. More...

StatusCode	addAlgorithmNode (Gaudi::Algorithm *daughterAlgo, const std::string &parentName)
	Add algorithm node. More...

AlgorithmNode *	getAlgorithmNode (const std::string &algoName) const
	Get the AlgorithmNode from by algorithm name using graph index. More...

StatusCode	addDecisionHubNode (Gaudi::Algorithm *daughterAlgo, const std::string &parentName, concurrency::Concurrent, concurrency::PromptDecision, concurrency::ModeOr, concurrency::AllPass, concurrency::Inverted)
	Add a node, which aggregates decisions of direct daughter nodes. More...

unsigned int	getControlFlowNodeCounter () const
	Get total number of control flow graph nodes. More...

void	rankAlgorithms (IGraphVisitor &ranker) const
	Rank Algorithm nodes by the number of data outputs. More...

const std::string &	name () const override
	Retrieve name of the service. More...

SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator. More...

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

void	enableAnalysis ()
	BGL-based facilities. More...

PRVertexDesc	node (const std::string &) const

std::string	dumpDataFlow () const
	Print out all data origins and destinations, as reflected in the EF graph. More...

std::string	dumpControlFlow () const
	Print out control flow of Algorithms and Sequences. More...

void	dumpPrecRules (const boost::filesystem::path &, const EventSlot &slot)
	dump to file the precedence rules More...

void	dumpPrecTrace (const boost::filesystem::path &, const EventSlot &slot)
	dump to file the precedence trace More...

void	addEdgeToPrecTrace (const AlgorithmNode u, const AlgorithmNode v)
	set cause-effect connection between two algorithms in the precedence trace More...

void	dumpControlFlow (std::ostringstream &, ControlFlowNode *, const int &) const

Public Member Functions inherited from CommonMessaging< IPrecedenceRulesGraph >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream) More...

bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...

Private Attributes
DecisionNode *	m_headNode = nullptr
	the head node of the control flow graph More...

std::unordered_map< std::string, std::unique_ptr< AlgorithmNode > >	m_algoNameToAlgoNodeMap
	Index: map of algorithm's name to AlgorithmNode. More...

std::unordered_map< std::string, std::unique_ptr< DecisionNode > >	m_decisionNameToDecisionHubMap
	Index: map of decision's name to DecisionHub. More...

std::unordered_map< DataObjID, std::unique_ptr< DataNode >, DataObjID_Hasher >	m_dataPathToDataNodeMap
	Index: map of data path to DataNode. More...

std::unordered_map< std::string, DataObjIDColl >	m_algoNameToAlgoInputsMap
	Indexes: maps of algorithm's name to algorithm's inputs/outputs. More...

std::unordered_map< std::string, DataObjIDColl >	m_algoNameToAlgoOutputsMap

unsigned int	m_nodeCounter = 0
	Total number of nodes in the graph. More...

unsigned int	m_algoCounter = 0
	Total number of algorithm nodes in the graph. More...

SmartIF< ISvcLocator >	m_svcLocator
	Service locator (needed to access the MessageSvc) More...

const std::string	m_name

precedence::PrecTrace	m_precTrace
	facilities for algorithm precedence tracing More...

std::map< std::string, precedence::AlgoTraceVertex >	m_prec_trace_map

bool	m_enableAnalysis { false }

precedence::PRGraph	m_PRGraph
	BGL-based graph of precedence rules. More...

bool	m_conditionsRealmEnabled { false }
	Enable conditions realm of precedence rules. More...

Additional Inherited Members
Public Types inherited from CommonMessaging< IPrecedenceRulesGraph >
using	base_class = CommonMessaging

Protected Member Functions inherited from CommonMessaging< IPrecedenceRulesGraph >
MSG::Level	setUpMessaging () const
	Set up local caches. More...

MSG::Level	resetMessaging ()
	Reinitialize internal states. More...

void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...

Detailed Description

Definition at line 618 of file PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

◆ PrecedenceRulesGraph()

concurrency::PrecedenceRulesGraph::PrecedenceRulesGraph	(	const std::string &	name,
		SmartIF< ISvcLocator >	svc
	)

inline

Constructor.

Definition at line 621 of file PrecedenceRulesGraph.h.

                                                                             : m_svcLocator( svc ), m_name( name ) {
       // make sure that CommonMessaging is initialized
       setUpMessaging();
     }

Member Function Documentation

◆ accept()

void concurrency::PrecedenceRulesGraph::accept ( IGraphVisitor & visitor ) const

An entry point to visit all graph nodes.

Definition at line 538 of file PrecedenceRulesGraph.cpp.

                                                                   {
     // iterate through Algorithm nodes
     for ( auto& pr : m_algoNameToAlgoNodeMap ) pr.second->accept( visitor );
  
     // iterate through DecisionHub nodes
     for ( auto& pr : m_decisionNameToDecisionHubMap ) pr.second->accept( visitor );
  
     // iterate through Data [and Conditions] nodes
     for ( auto& pr : m_dataPathToDataNodeMap ) pr.second->accept( visitor );
   }

◆ addAlgorithmNode()

StatusCode concurrency::PrecedenceRulesGraph::addAlgorithmNode	(	Gaudi::Algorithm *	daughterAlgo,
		const std::string &	parentName
	)

Add algorithm node.

Create new, or fetch existent, AlgorithmNode

Attach AlgorithmNode to its parent DecisionNode

Definition at line 372 of file PrecedenceRulesGraph.cpp.

                                                                                                        {
  
     StatusCode sc = StatusCode::SUCCESS;
  
  
     auto& algoName = algo->name();
  
     concurrency::AlgorithmNode* algoNode;
  
     auto itA = m_algoNameToAlgoNodeMap.find( algoName );
     if ( itA != m_algoNameToAlgoNodeMap.end() ) {
       algoNode = itA->second.get();
     } else {
       auto r = m_algoNameToAlgoNodeMap.emplace(
           algoName, std::make_unique<concurrency::AlgorithmNode>( *this, algo, m_nodeCounter, m_algoCounter ) );
       algoNode = r.first->second.get();
  
       // Mirror AlgorithmNode in the BGL-based graph
       if ( m_enableAnalysis ) { boost::add_vertex( AlgoProps( algo, m_nodeCounter, m_algoCounter ), m_PRGraph ); }
       ++m_nodeCounter;
       ++m_algoCounter;
       ON_VERBOSE verbose() << "AlgorithmNode '" << algoName << "' added @ " << algoNode << endmsg;
  
       registerIODataObjects( algo );
     }
  
     auto itP = m_decisionNameToDecisionHubMap.find( parentName );
     if ( itP != m_decisionNameToDecisionHubMap.end() ) {
       auto parentNode = itP->second.get();
  
       parentNode->addDaughterNode( algoNode );
       algoNode->addParentNode( parentNode );
  
       // Mirror algorithm to CF parent relationship in the BGL-based graph
       if ( m_enableAnalysis ) boost::add_edge( node( algo->name() ), node( parentName ), m_PRGraph );
  
       ON_VERBOSE verbose() << "Attached AlgorithmNode '" << algo->name() << "' to parent DecisionNode '" << parentName
                            << "'" << endmsg;
     } else {
       sc = StatusCode::FAILURE;
       error() << "Parent DecisionNode '" << parentName << "' was not found" << endmsg;
     }
  
     return sc;
   }

◆ addDataNode()

StatusCode concurrency::PrecedenceRulesGraph::addDataNode ( const DataObjID & dataPath )

Add DataNode that represents DataObject.

Definition at line 421 of file PrecedenceRulesGraph.cpp.

                                                                           {
  
     auto itD = m_dataPathToDataNodeMap.find( dataPath );
     if ( itD != m_dataPathToDataNodeMap.end() ) return StatusCode::SUCCESS;
  
     std::unique_ptr<concurrency::DataNode> dataNode;
     if ( !m_conditionsRealmEnabled ) {
       dataNode = std::make_unique<concurrency::DataNode>( *this, dataPath );
       ON_VERBOSE verbose() << "  DataNode " << dataPath << " added @ " << dataNode.get() << endmsg;
       // Mirror the action above in the BGL-based graph
       if ( m_enableAnalysis ) boost::add_vertex( DataProps( dataPath ), m_PRGraph );
     } else {
       SmartIF<ICondSvc> condSvc{ serviceLocator()->service( "CondSvc", false ) };
       if ( condSvc->isRegistered( dataPath ) ) {
         dataNode = std::make_unique<concurrency::ConditionNode>( *this, dataPath, condSvc );
         ON_VERBOSE verbose() << "  ConditionNode " << dataPath << " added @ " << dataNode.get() << endmsg;
         // Mirror the action above in the BGL-based graph
         if ( m_enableAnalysis ) boost::add_vertex( CondDataProps( dataPath ), m_PRGraph );
       } else {
         dataNode = std::make_unique<concurrency::DataNode>( *this, dataPath );
         ON_VERBOSE verbose() << "  DataNode " << dataPath << " added @ " << dataNode.get() << endmsg;
         // Mirror the action above in the BGL-based graph
         if ( m_enableAnalysis ) boost::add_vertex( DataProps( dataPath ), m_PRGraph );
       }
     }
     m_dataPathToDataNodeMap.emplace( dataPath, std::move( dataNode ) );
     return StatusCode::SUCCESS;
   }

◆ addDecisionHubNode()

StatusCode concurrency::PrecedenceRulesGraph::addDecisionHubNode	(	Gaudi::Algorithm *	daughterAlgo,
		const std::string &	parentName,
		concurrency::Concurrent	modeConcurrent,
		concurrency::PromptDecision	modePromptDecision,
		concurrency::ModeOr	modeOR,
		concurrency::AllPass	allPass,
		concurrency::Inverted	isInverted
	)

Add a node, which aggregates decisions of direct daughter nodes.

Create new, or fetch existent, DecisionNode

Attach DecisionNode to its parent DecisionNode

Definition at line 451 of file PrecedenceRulesGraph.cpp.

                                                                                                              {
  
     StatusCode sc = StatusCode::SUCCESS;
  
  
     auto& decisionHubName = decisionHubAlgo->name();
  
     auto                       itA = m_decisionNameToDecisionHubMap.find( decisionHubName );
     concurrency::DecisionNode* decisionHubNode;
     if ( itA != m_decisionNameToDecisionHubMap.end() ) {
       decisionHubNode = itA->second.get();
     } else {
       auto r = m_decisionNameToDecisionHubMap.emplace(
           decisionHubName,
           std::make_unique<concurrency::DecisionNode>( *this, m_nodeCounter, decisionHubName, modeConcurrent,
                                                        modePromptDecision, modeOR, allPass, isInverted ) );
       decisionHubNode = r.first->second.get();
       // Mirror DecisionNode in the BGL-based graph
       if ( m_enableAnalysis ) {
         boost::add_vertex( DecisionHubProps( decisionHubName, m_nodeCounter, modeConcurrent, modePromptDecision, modeOR,
                                              allPass, isInverted ),
                            m_PRGraph );
       }
  
       ++m_nodeCounter;
  
       ON_VERBOSE verbose() << "DecisionNode '" << decisionHubName << "' added @ " << decisionHubNode << endmsg;
     }
  
     auto itP = m_decisionNameToDecisionHubMap.find( parentName );
     if ( itP != m_decisionNameToDecisionHubMap.end() ) {
       auto parentNode = itP->second.get();
       parentNode->addDaughterNode( decisionHubNode );
       decisionHubNode->addParentNode( parentNode );
  
       // Mirror DecisionNode-to-DecisionNode relationship in the BGL-based graph
       if ( m_enableAnalysis ) boost::add_edge( node( decisionHubName ), node( parentName ), m_PRGraph );
  
       ON_VERBOSE verbose() << "Attached DecisionNode '" << decisionHubName << "' to parent DecisionNode '" << parentName
                            << "'" << endmsg;
     } else {
       sc = StatusCode::FAILURE;
       error() << "Parent DecisionNode '" << parentName << "' was not found" << endmsg;
     }
  
     return sc;
   }

◆ addEdgeToPrecTrace()

void concurrency::PrecedenceRulesGraph::addEdgeToPrecTrace	(	const AlgorithmNode *	u,
		const AlgorithmNode *	v
	)

set cause-effect connection between two algorithms in the precedence trace

Definition at line 721 of file PrecedenceRulesGraph.cpp.

                                                                                                 {
  
     std::string u_name = u == nullptr ? "ENTRY" : u->name();
     std::string v_name = v->name();
  
     precedence::AlgoTraceVertex source;
  
     if ( !u ) {
       auto itT = m_prec_trace_map.find( "ENTRY" );
       if ( itT != m_prec_trace_map.end() ) {
         source = itT->second;
       } else {
         source                    = boost::add_vertex( precedence::AlgoTraceProps( "ENTRY" ), m_precTrace );
         m_prec_trace_map["ENTRY"] = source;
       }
     } else {
       auto itS = m_prec_trace_map.find( u_name );
       if ( itS != m_prec_trace_map.end() ) {
         source = itS->second;
       } else {
  
         source =
             boost::add_vertex( precedence::AlgoTraceProps( u_name, u->getAlgoIndex(), u->getRank() ), m_precTrace );
         m_prec_trace_map[u_name] = source;
       }
     }
  
     precedence::AlgoTraceVertex target;
  
     auto itP = m_prec_trace_map.find( v_name );
     if ( itP != m_prec_trace_map.end() ) {
       target = itP->second;
     } else {
  
       target = boost::add_vertex( precedence::AlgoTraceProps( v_name, v->getAlgoIndex(), v->getRank() ), m_precTrace );
       m_prec_trace_map[v_name] = target;
     }
  
     boost::add_edge( source, target, m_precTrace );
  
     ON_DEBUG debug() << u_name << "-->" << v_name << " precedence trait added" << endmsg;
   }

◆ addHeadNode()

void concurrency::PrecedenceRulesGraph::addHeadNode	(	const std::string &	headName,
		concurrency::Concurrent	modeConcurrent,
		concurrency::PromptDecision	modePromptDecision,
		concurrency::ModeOr	modeOR,
		concurrency::AllPass	allPass,
		concurrency::Inverted	isInverted
	)

Add a node, which has no parents.

Definition at line 504 of file PrecedenceRulesGraph.cpp.

                                                                                                        {
  
     auto itH = m_decisionNameToDecisionHubMap.find( headName );
     if ( itH != m_decisionNameToDecisionHubMap.end() ) {
       m_headNode = itH->second.get();
     } else {
       auto r = m_decisionNameToDecisionHubMap.emplace(
           headName, std::make_unique<concurrency::DecisionNode>( *this, m_nodeCounter, headName, modeConcurrent,
                                                                  modePromptDecision, modeOR, allPass, isInverted ) );
       m_headNode = r.first->second.get();
  
       // Mirror the action above in the BGL-based graph
       if ( m_enableAnalysis ) {
         boost::add_vertex( DecisionHubProps( headName, m_nodeCounter, modeConcurrent, modePromptDecision, modeOR,
                                              allPass, isInverted ),
                            m_PRGraph );
       }
  
       ++m_nodeCounter;
     }
   }

◆ buildDataDependenciesRealm()

StatusCode concurrency::PrecedenceRulesGraph::buildDataDependenciesRealm ( )

Build data dependency realm WITH data object nodes participating.

Definition at line 318 of file PrecedenceRulesGraph.cpp.

                                                               {
  
     StatusCode global_sc = StatusCode::SUCCESS;
  
     // Production of DataNodes by AlgorithmNodes (DataNodes are created here)
     std::vector<decltype( m_algoNameToAlgoNodeMap )::value_type*> sortedAlgs;
     for ( auto& algo : m_algoNameToAlgoNodeMap ) { sortedAlgs.push_back( &algo ); }
     std::sort( sortedAlgs.begin(), sortedAlgs.end(),
                []( const auto* a, const auto* b ) { return a->first < b->first; } );
     for ( auto* algo : sortedAlgs ) {
  
       auto& outputs = m_algoNameToAlgoOutputsMap[algo->first];
       for ( auto output : outputs ) {
         const auto sc = addDataNode( output );
         if ( !sc.isSuccess() ) {
           error() << "Extra producer (" << algo->first << ") for DataObject @ " << output
                   << " has been detected: this is not allowed." << endmsg;
           global_sc = sc;
         }
         auto dataNode = getDataNode( output );
         dataNode->addProducerNode( algo->second.get() );
         algo->second->addOutputDataNode( dataNode );
  
         // Mirror the action above in the BGL-based graph
         if ( m_enableAnalysis ) boost::add_edge( node( algo->second->name() ), node( output.fullKey() ), m_PRGraph );
       }
     }
  
     // Consumption of DataNodes by AlgorithmNodes
     sortedAlgs.clear();
     for ( auto& algo : m_algoNameToAlgoNodeMap ) { sortedAlgs.push_back( &algo ); }
     std::sort( sortedAlgs.begin(), sortedAlgs.end(),
                []( const auto* a, const auto* b ) { return a->first < b->first; } );
     for ( auto* algo : sortedAlgs ) {
  
       for ( auto input : m_algoNameToAlgoInputsMap[algo->first] ) {
  
         auto itP = m_dataPathToDataNodeMap.find( input );
  
         DataNode* dataNode = ( itP != m_dataPathToDataNodeMap.end() ? getDataNode( input ) : nullptr );
         if ( dataNode ) {
           dataNode->addConsumerNode( algo->second.get() );
           algo->second->addInputDataNode( dataNode );
  
           // Mirror the action above in the BGL-based graph
           if ( m_enableAnalysis ) boost::add_edge( node( input.fullKey() ), node( algo->second->name() ), m_PRGraph );
         }
       }
     }
  
     return global_sc;
   }

◆ dumpControlFlow() [1/2]

std::string concurrency::PrecedenceRulesGraph::dumpControlFlow ( ) const

Print out control flow of Algorithms and Sequences.

Definition at line 560 of file PrecedenceRulesGraph.cpp.

                                                         {
     std::ostringstream ost;
     dumpControlFlow( ost, m_headNode, 0 );
     return ost.str();
   }

◆ dumpControlFlow() [2/2]

void concurrency::PrecedenceRulesGraph::dumpControlFlow	(	std::ostringstream &	ost,
		ControlFlowNode *	node,
		const int &	indent
	)		const

Definition at line 566 of file PrecedenceRulesGraph.cpp.

                                                                         {
     ost << std::string( indent * 2, ' ' );
     DecisionNode*  dn = dynamic_cast<DecisionNode*>( node );
     AlgorithmNode* an = dynamic_cast<AlgorithmNode*>( node );
     if ( dn != 0 ) {
       if ( node != m_headNode ) {
         ost << node->name() << " [Seq] ";
         ost << ( ( dn->m_modeConcurrent ) ? " [Concurrent] " : " [Sequential] " );
         ost << ( ( dn->m_modePromptDecision ) ? " [Prompt] " : "" );
         ost << ( ( dn->m_modeOR ) ? " [OR] " : "" );
         ost << ( ( dn->m_allPass ) ? " [PASS] " : "" );
         ost << "\n";
       }
       for ( const auto& i : dn->getDaughters() ) dumpControlFlow( ost, i, indent + 1 );
     } else if ( an != 0 ) {
       ost << node->name() << " [Alg] ";
       if ( an != 0 ) {
         auto ar = an->getAlgorithm();
         ost << " [n= " << ar->cardinality() << "]";
         ost << ( ( !ar->isClonable() ) ? " [unclonable] " : "" );
       }
       ost << "\n";
     }
   }

◆ dumpDataFlow()

std::string concurrency::PrecedenceRulesGraph::dumpDataFlow ( ) const

Print out all data origins and destinations, as reflected in the EF graph.

Definition at line 593 of file PrecedenceRulesGraph.cpp.

                                                      {
  
     const char         idt[] = "      ";
     std::ostringstream ost;
  
     ost << "\n" << idt << "====================================\n";
     ost << idt << "Data origins and destinations:\n";
     ost << idt << "====================================\n";
  
     std::vector<const DataObjID*> vec;
     vec.reserve( m_dataPathToDataNodeMap.size() );
     for ( auto& pair : m_dataPathToDataNodeMap ) { vec.push_back( &pair.first ); }
     std::sort( vec.begin(), vec.end(),
                []( const DataObjID* a, const DataObjID* b ) { return a->fullKey() < b->fullKey(); } );
  
     for ( const DataObjID* id : vec ) {
       const DataNode& node = *m_dataPathToDataNodeMap.find( *id )->second;
  
       for ( auto algoNode : node.getProducers() ) ost << idt << "  " << algoNode->name() << "\n";
  
       ost << idt << "  V\n";
       ost << idt << "  o " << id << "\n";
       ost << idt << "  V\n";
  
       for ( auto algoNode : node.getConsumers() ) ost << idt << "  " << algoNode->name() << "\n";
  
       ost << idt << "====================================\n";
     }
  
     return ost.str();
   }

◆ dumpPrecRules()

void concurrency::PrecedenceRulesGraph::dumpPrecRules	(	const boost::filesystem::path &	fileName,
		const EventSlot &	slot
	)

dump to file the precedence rules

Definition at line 627 of file PrecedenceRulesGraph.cpp.

                                                                                                        {
     std::ofstream myfile;
     myfile.open( fileName.c_str(), std::ios::app );
  
     // Declare properties to dump
     boost::dynamic_properties dp;
  
     dp.property( "Entity",
                  boost::make_transform_value_property_map(
                      []( const VariantVertexProps& v ) {
                        return std::visit( []( const auto& w ) { return boost::lexical_cast<std::string>( w ); }, v );
                      },
                      boost::get( boost::vertex_bundle, m_PRGraph ) ) );
  
     auto add_prop = [&]( auto name, auto&& vis ) {
       dp.property( name, boost::make_transform_value_property_map(
                              [vis = std::forward<decltype( vis )>( vis )]( const VariantVertexProps& v ) {
                                return std::visit( vis, v );
                              },
                              boost::get( boost::vertex_bundle, m_PRGraph ) ) );
     };
  
     add_prop( "Name", precedence::VertexName() );
     add_prop( "Mode", precedence::GroupMode() );
     add_prop( "Logic", precedence::GroupLogic() );
     add_prop( "Decision Negation", precedence::DecisionNegation() );
     add_prop( "Negative Decision Inversion", precedence::AllPass() );
     add_prop( "Exit Policy", precedence::GroupExit() );
     add_prop( "Operations", precedence::Operations() );
     add_prop( "CF Decision", precedence::CFDecision( slot ) );
     add_prop( "State", precedence::EntityState( slot, serviceLocator(), m_conditionsRealmEnabled ) );
     add_prop( "Start Time (Epoch ns)", precedence::StartTime( slot, serviceLocator() ) );
     add_prop( "End Time (Epoch ns)", precedence::EndTime( slot, serviceLocator() ) );
     add_prop( "Runtime (ns)", precedence::Duration( slot, serviceLocator() ) );
  
     boost::write_graphml( myfile, m_PRGraph, dp );
  
     myfile.close();
   }

◆ dumpPrecTrace()

void concurrency::PrecedenceRulesGraph::dumpPrecTrace	(	const boost::filesystem::path &	fileName,
		const EventSlot &	slot
	)

dump to file the precedence trace

Definition at line 668 of file PrecedenceRulesGraph.cpp.

                                                                                                        {
     std::ofstream myfile;
     myfile.open( fileName.c_str(), std::ios::app );
  
     // Fill runtimes (as this could not be done on the fly during trace assembling)
     SmartIF<ITimelineSvc> timelineSvc = m_svcLocator->service<ITimelineSvc>( "TimelineSvc", false );
     if ( !timelineSvc.isValid() ) {
       warning() << "Failed to get the TimelineSvc, timing will not be added to "
                 << "the task precedence trace dump" << endmsg;
     } else {
  
       std::vector<long long int> start_times;
  
       for ( auto vp = vertices( m_precTrace ); vp.first != vp.second; ++vp.first ) {
         TimelineEvent te{};
         te.algorithm = m_precTrace[*vp.first].m_name;
         te.slot      = slot.eventContext->slot();
         te.event     = slot.eventContext->evt();
         timelineSvc->getTimelineEvent( te );
  
         long int runtime{ std::chrono::duration_cast<std::chrono::microseconds>( te.end - te.start ).count() };
         m_precTrace[*vp.first].m_runtime = runtime;
  
         long long int start{
             std::chrono::duration_cast<std::chrono::nanoseconds>( te.start.time_since_epoch() ).count() };
         m_precTrace[*vp.first].m_start = start;
         if ( start != 0 ) start_times.push_back( start );
       }
  
       auto min = std::min_element( start_times.begin(), start_times.end() );
  
       for ( auto vp = vertices( m_precTrace ); vp.first != vp.second; ++vp.first ) {
  
         auto& oldValue = m_precTrace[*vp.first].m_start;
  
         if ( oldValue != 0 ) oldValue = oldValue - *min;
       }
     }
  
     // Declare properties to dump
     boost::dynamic_properties dp;
     using boost::get;
     using precedence::AlgoTraceProps;
     dp.property( "Name", get( &AlgoTraceProps::m_name, m_precTrace ) );
     dp.property( "Rank", get( &AlgoTraceProps::m_rank, m_precTrace ) );
     dp.property( "Run Time (us)", get( &AlgoTraceProps::m_runtime, m_precTrace ) );
     dp.property( "Start Time (ns)", get( &AlgoTraceProps::m_start, m_precTrace ) );
  
     boost::write_graphml( myfile, m_precTrace, dp );
  
     myfile.close();
   }

◆ enableAnalysis()

void concurrency::PrecedenceRulesGraph::enableAnalysis ( )

inline

BGL-based facilities.

Definition at line 671 of file PrecedenceRulesGraph.h.

671 { m_enableAnalysis = true; };

◆ getAlgorithmNode()

AlgorithmNode* concurrency::PrecedenceRulesGraph::getAlgorithmNode ( const std::string & algoName ) const

inline

Get the AlgorithmNode from by algorithm name using graph index.

Definition at line 649 of file PrecedenceRulesGraph.h.

                                                                        {
       return m_algoNameToAlgoNodeMap.at( algoName ).get();
     }

◆ getControlFlowNodeCounter()

unsigned int concurrency::PrecedenceRulesGraph::getControlFlowNodeCounter ( ) const

inline

Get total number of control flow graph nodes.

Definition at line 657 of file PrecedenceRulesGraph.h.

657 { return m_nodeCounter; }

◆ getDataNode()

DataNode* concurrency::PrecedenceRulesGraph::getDataNode ( const DataObjID & dataPath ) const

inline

Get DataNode by DataObject path using graph index.

Definition at line 635 of file PrecedenceRulesGraph.h.

635 { return m_dataPathToDataNodeMap.at( dataPath ).get(); }

◆ getHeadNode()

DecisionNode* concurrency::PrecedenceRulesGraph::getHeadNode ( ) const

inline

Get head node.

Definition at line 645 of file PrecedenceRulesGraph.h.

645 { return m_headNode; };

◆ initialize()

StatusCode concurrency::PrecedenceRulesGraph::initialize ( )

Initialize graph.

Definition at line 220 of file PrecedenceRulesGraph.cpp.

                                               {
     if ( serviceLocator()->existsService( "CondSvc" ) ) {
       SmartIF<ICondSvc> condSvc{ serviceLocator()->service( "CondSvc" ) };
       if ( condSvc.isValid() ) {
         info() << "CondSvc found. DF precedence rules will be augmented with 'Conditions'" << endmsg;
         m_conditionsRealmEnabled = true;
       }
     }
  
     // Detach condition algorithms from the CF realm
     if ( m_conditionsRealmEnabled ) {
       SmartIF<ICondSvc> condSvc{ serviceLocator()->service( "CondSvc", false ) };
       auto&             condAlgs = condSvc->condAlgs();
       for ( const auto algo : condAlgs ) {
         auto itA = m_algoNameToAlgoNodeMap.find( algo->name() );
         if ( itA != m_algoNameToAlgoNodeMap.end() ) {
           concurrency::AlgorithmNode* algoNode = itA->second.get();
           debug() << "Detaching condition algorithm '" << algo->name() << "' from the CF realm.." << endmsg;
           for ( auto parent : algoNode->getParentDecisionHubs() ) {
             parent->m_children.erase( std::remove( parent->m_children.begin(), parent->m_children.end(), algoNode ),
                                       parent->m_children.end() );
             // clean up also auxiliary BGL-based graph of precedence rules
             if ( m_enableAnalysis ) boost::remove_edge( node( algoNode->name() ), node( parent->name() ), m_PRGraph );
           }
           algoNode->m_parents.clear();
  
         } else {
           warning() << "Algorithm '" << algo->name() << "' is not registered in the graph" << endmsg;
         }
       }
     }
  
     StatusCode sc = buildDataDependenciesRealm();
  
     if ( !sc.isSuccess() ) error() << "Could not build the data dependency realm." << endmsg;
  
     return sc;
   }

◆ name()

const std::string& concurrency::PrecedenceRulesGraph::name ( ) const

inlineoverride

Retrieve name of the service.

Definition at line 663 of file PrecedenceRulesGraph.h.

663 { return m_name; }

◆ node()

PRVertexDesc concurrency::PrecedenceRulesGraph::node ( const std::string & name ) const

Definition at line 529 of file PrecedenceRulesGraph.cpp.

                                                                        {
     auto vp = vertices( m_PRGraph );
     auto i  = std::find_if( vp.first, vp.second, [&]( const PRVertexDesc& v ) {
       return std::visit( precedence::VertexName(), m_PRGraph[v] ) == name;
     } );
     return i != vp.second ? *i : PRVertexDesc{};
   }

◆ printState()

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

Print a string representing the control flow state.

Definition at line 260 of file PrecedenceRulesGraph.cpp.

                                                                                     {
     if ( slot.parentSlot ) {
       // Start at sub-slot entry point
       m_decisionNameToDecisionHubMap.at( slot.entryPoint )->printState( output, slot, recursionLevel );
     } else {
       // Start at the head node for whole-event slots
       m_headNode->printState( output, slot, recursionLevel );
     }
  
     // Find detached conditions algs in interesting states
     if ( m_conditionsRealmEnabled ) {
       bool              firstPrint = true;
       SmartIF<ICondSvc> condSvc{ serviceLocator()->service( "CondSvc", false ) };
       auto&             condAlgs = condSvc->condAlgs();
       for ( const auto algo : condAlgs ) {
         auto itA = m_algoNameToAlgoNodeMap.find( algo->name() );
         if ( itA != m_algoNameToAlgoNodeMap.end() ) {
  
           concurrency::AlgorithmNode* algoNode = itA->second.get();
  
           // Ignore boring states (reduces verbosity)
           auto& thisState = slot.algsStates[algoNode->getAlgoIndex()];
           if ( thisState == AlgsExecutionStates::State::INITIAL ||
                thisState == AlgsExecutionStates::State::EVTACCEPTED )
             continue;
  
           // Make output
           if ( firstPrint ) {
             firstPrint = false;
             output << std::endl << "Detached algorithms:" << std::endl;
           }
           algoNode->printState( output, slot, recursionLevel );
         }
       }
     }
   }

◆ rankAlgorithms()

void concurrency::PrecedenceRulesGraph::rankAlgorithms ( IGraphVisitor & ranker ) const

Rank Algorithm nodes by the number of data outputs.

Definition at line 550 of file PrecedenceRulesGraph.cpp.

                                                                          {
  
     info() << "Starting ranking by data outputs .. " << endmsg;
     for ( auto& pair : m_algoNameToAlgoNodeMap ) {
       ON_DEBUG debug() << "  Ranking " << pair.first << "... " << endmsg;
       pair.second->accept( ranker );
       ON_DEBUG debug() << "  ... rank of " << pair.first << ": " << pair.second->getRank() << endmsg;
     }
   }

◆ registerIODataObjects()

void concurrency::PrecedenceRulesGraph::registerIODataObjects ( const Gaudi::Algorithm * algo )

Register algorithm in the Data Dependency index.

Definition at line 299 of file PrecedenceRulesGraph.cpp.

                                                                                {
  
     const std::string& algoName = algo->name();
  
     m_algoNameToAlgoInputsMap[algoName]  = algo->inputDataObjs();
     m_algoNameToAlgoOutputsMap[algoName] = algo->outputDataObjs();
  
     ON_VERBOSE {
       verbose() << "    Inputs of " << algoName << ": ";
       for ( auto tag : algo->inputDataObjs() ) verbose() << tag << " | ";
       verbose() << endmsg;
  
       verbose() << "    Outputs of " << algoName << ": ";
       for ( auto tag : algo->outputDataObjs() ) verbose() << tag << " | ";
       verbose() << endmsg;
     }
   }

◆ serviceLocator()

SmartIF<ISvcLocator>& concurrency::PrecedenceRulesGraph::serviceLocator ( ) const

inlineoverride

Retrieve pointer to service locator.

Definition at line 665 of file PrecedenceRulesGraph.h.

665 { return m_svcLocator; }

Member Data Documentation

◆ m_algoCounter

unsigned int concurrency::PrecedenceRulesGraph::m_algoCounter = 0

private

Total number of algorithm nodes in the graph.

Definition at line 703 of file PrecedenceRulesGraph.h.

◆ m_algoNameToAlgoInputsMap

std::unordered_map<std::string, DataObjIDColl> concurrency::PrecedenceRulesGraph::m_algoNameToAlgoInputsMap

private

Indexes: maps of algorithm's name to algorithm's inputs/outputs.

Definition at line 697 of file PrecedenceRulesGraph.h.

◆ m_algoNameToAlgoNodeMap

std::unordered_map<std::string, std::unique_ptr<AlgorithmNode> > concurrency::PrecedenceRulesGraph::m_algoNameToAlgoNodeMap

private

Index: map of algorithm's name to AlgorithmNode.

Definition at line 691 of file PrecedenceRulesGraph.h.

◆ m_algoNameToAlgoOutputsMap

std::unordered_map<std::string, DataObjIDColl> concurrency::PrecedenceRulesGraph::m_algoNameToAlgoOutputsMap

private

Definition at line 698 of file PrecedenceRulesGraph.h.

◆ m_conditionsRealmEnabled

bool concurrency::PrecedenceRulesGraph::m_conditionsRealmEnabled { false }

private

Enable conditions realm of precedence rules.

Definition at line 717 of file PrecedenceRulesGraph.h.

◆ m_dataPathToDataNodeMap

std::unordered_map<DataObjID, std::unique_ptr<DataNode>, DataObjID_Hasher> concurrency::PrecedenceRulesGraph::m_dataPathToDataNodeMap

private

Index: map of data path to DataNode.

Definition at line 695 of file PrecedenceRulesGraph.h.

◆ m_decisionNameToDecisionHubMap

std::unordered_map<std::string, std::unique_ptr<DecisionNode> > concurrency::PrecedenceRulesGraph::m_decisionNameToDecisionHubMap

private

Index: map of decision's name to DecisionHub.

Definition at line 693 of file PrecedenceRulesGraph.h.

◆ m_enableAnalysis

bool concurrency::PrecedenceRulesGraph::m_enableAnalysis { false }

private

Definition at line 712 of file PrecedenceRulesGraph.h.

◆ m_headNode

DecisionNode* concurrency::PrecedenceRulesGraph::m_headNode = nullptr

private

the head node of the control flow graph

Definition at line 689 of file PrecedenceRulesGraph.h.

◆ m_name

const std::string concurrency::PrecedenceRulesGraph::m_name

private

Definition at line 707 of file PrecedenceRulesGraph.h.

◆ m_nodeCounter

unsigned int concurrency::PrecedenceRulesGraph::m_nodeCounter = 0

private

Total number of nodes in the graph.

Definition at line 701 of file PrecedenceRulesGraph.h.

◆ m_prec_trace_map

std::map<std::string, precedence::AlgoTraceVertex> concurrency::PrecedenceRulesGraph::m_prec_trace_map

private

Definition at line 711 of file PrecedenceRulesGraph.h.

◆ m_precTrace

precedence::PrecTrace concurrency::PrecedenceRulesGraph::m_precTrace

private

facilities for algorithm precedence tracing

Definition at line 710 of file PrecedenceRulesGraph.h.

◆ m_PRGraph

precedence::PRGraph concurrency::PrecedenceRulesGraph::m_PRGraph

private

BGL-based graph of precedence rules.

Definition at line 714 of file PrecedenceRulesGraph.h.

◆ m_svcLocator

SmartIF<ISvcLocator> concurrency::PrecedenceRulesGraph::m_svcLocator

mutableprivate

Service locator (needed to access the MessageSvc)

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

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PrecedenceRulesGraph()

Member Function Documentation

◆ accept()

◆ addAlgorithmNode()

◆ addDataNode()

◆ addDecisionHubNode()

◆ addEdgeToPrecTrace()

◆ addHeadNode()

◆ buildDataDependenciesRealm()

◆ dumpControlFlow() [1/2]

◆ dumpControlFlow() [2/2]

◆ dumpDataFlow()

◆ dumpPrecRules()

◆ dumpPrecTrace()

◆ enableAnalysis()

◆ getAlgorithmNode()

◆ getControlFlowNodeCounter()

◆ getDataNode()

◆ getHeadNode()

◆ initialize()

◆ name()

◆ node()

◆ printState()

◆ rankAlgorithms()

◆ registerIODataObjects()

◆ serviceLocator()

Member Data Documentation

◆ m_algoCounter

◆ m_algoNameToAlgoInputsMap

◆ m_algoNameToAlgoNodeMap

◆ m_algoNameToAlgoOutputsMap

◆ m_conditionsRealmEnabled

◆ m_dataPathToDataNodeMap

◆ m_decisionNameToDecisionHubMap

◆ m_enableAnalysis

◆ m_headNode

◆ m_name

◆ m_nodeCounter

◆ m_prec_trace_map

◆ m_precTrace

◆ m_PRGraph

◆ m_svcLocator