#include <src/PRGraph/PrecedenceRulesGraph.h>

Inheritance diagram for concurrency::PrecedenceRulesGraph:

[legend]

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

Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor. More...

const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service. More...

MsgStream &	msgStream () const
	Return an uninitialized MsgStream. More...

MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts. More...

MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS) More...

MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL) More...

MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR) More...

MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR) More...

MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING) More...

MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO) More...

MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG) More...

MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE) More...

MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO) 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 632 of file PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

◆ PrecedenceRulesGraph()

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

inline

Constructor.

Definition at line 635 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 496 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,
		bool	inverted,
		bool	allPass
	)

Add algorithm node.

Create new, or fetch existent, AlgorithmNode

Attach AlgorithmNode to its parent DecisionNode

Definition at line 326 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, inverted,
                                                                   allPass ) );
       algoNode = r.first->second.get();
 
       // Mirror AlgorithmNode in the BGL-based graph
       if ( m_enableAnalysis ) {
         boost::add_vertex( AlgoProps( algo, m_nodeCounter, m_algoCounter, inverted, allPass ), 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 379 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 409 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 652 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", -1, -1, -1.0 ), 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(), -1 ), 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(), -1 ), 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 462 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 280 of file PrecedenceRulesGraph.cpp.

                                                               {
 
     StatusCode global_sc( StatusCode::SUCCESS, true );
 
     // Production of DataNodes by AlgorithmNodes (DataNodes are created here)
     for ( auto& algo : m_algoNameToAlgoNodeMap ) {
 
       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
     for ( auto& algo : m_algoNameToAlgoNodeMap ) {
 
       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 518 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 524 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 551 of file PrecedenceRulesGraph.cpp.

                                                      {
 
     const char         idt[] = "      ";
     std::ostringstream ost;
 
     ost << "\n" << idt << "====================================\n";
     ost << idt << "Data origins and destinations:\n";
     ost << idt << "====================================\n";
 
     for ( auto& pair : m_dataPathToDataNodeMap ) {
 
       for ( auto algoNode : pair.second->getProducers() ) ost << idt << "  " << algoNode->name() << "\n";
 
       ost << idt << "  V\n";
       ost << idt << "  o " << pair.first << "\n";
       ost << idt << "  V\n";
 
       for ( auto algoNode : pair.second->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 578 of file PrecedenceRulesGraph.cpp.

                                                                                                        {
     boost::filesystem::ofstream myfile;
     myfile.open( fileName, 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 )

dump to file the precedence trace

Definition at line 619 of file PrecedenceRulesGraph.cpp.

                                                                                 {
     boost::filesystem::ofstream myfile;
     myfile.open( fileName, 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 {
 
       for ( auto vp = vertices( m_precTrace ); vp.first != vp.second; ++vp.first ) {
         TimelineEvent te{};
         te.algorithm = m_precTrace[*vp.first].m_name;
         timelineSvc->getTimelineEvent( te );
         int runtime = std::chrono::duration_cast<std::chrono::microseconds>( te.end - te.start ).count();
         m_precTrace[*vp.first].m_runtime = runtime;
       }
     }
 
     // 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( "Runtime", get( &AlgoTraceProps::m_runtime, m_precTrace ) );
 
     boost::write_graphml( myfile, m_precTrace, dp );
 
     myfile.close();
   }

◆ enableAnalysis()

void concurrency::PrecedenceRulesGraph::enableAnalysis ( )

inline

BGL-based facilities.

Definition at line 694 of file PrecedenceRulesGraph.h.

694 { m_enableAnalysis = true; };

concurrency::PrecedenceRulesGraph::m_enableAnalysis

bool m_enableAnalysis

Definition: PrecedenceRulesGraph.h:735

◆ getAlgorithmNode()

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

inline

Get the AlgorithmNode from by algorithm name using graph index.

Definition at line 664 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 672 of file PrecedenceRulesGraph.h.

672 { return m_nodeCounter; }

concurrency::PrecedenceRulesGraph::m_nodeCounter

unsigned int m_nodeCounter

Total number of nodes in the graph.

Definition: PrecedenceRulesGraph.h:724

◆ getDataNode()

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

inline

Get DataNode by DataObject path using graph index.

Definition at line 649 of file PrecedenceRulesGraph.h.

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

concurrency::PrecedenceRulesGraph::m_dataPathToDataNodeMap

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

Index: map of data path to DataNode.

Definition: PrecedenceRulesGraph.h:718

◆ getHeadNode()

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

inline

Get head node.

Definition at line 659 of file PrecedenceRulesGraph.h.

659 { return m_headNode; };

concurrency::PrecedenceRulesGraph::m_headNode

DecisionNode * m_headNode

the head node of the control flow graph

Definition: PrecedenceRulesGraph.h:712

◆ initialize()

StatusCode concurrency::PrecedenceRulesGraph::initialize ( )

Initialize graph.

Definition at line 219 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;
 
     ON_DEBUG debug() << dumpDataFlow() << endmsg;
 
     return sc;
   }

◆ name()

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

inlineoverride

Retrieve name of the service.

Definition at line 678 of file PrecedenceRulesGraph.h.

678 { return m_name; }

concurrency::PrecedenceRulesGraph::m_name

const std::string m_name

Definition: PrecedenceRulesGraph.h:730

◆ node()

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

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

inline

Print a string representing the control flow state.

Definition at line 683 of file PrecedenceRulesGraph.h.

                                                                                                           {
       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 );
       }
     }

◆ rankAlgorithms()

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

Rank Algorithm nodes by the number of data outputs.

Definition at line 508 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 261 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 680 of file PrecedenceRulesGraph.h.

680 { return m_svcLocator; }

concurrency::PrecedenceRulesGraph::m_svcLocator

SmartIF< ISvcLocator > m_svcLocator

Service locator (needed to access the MessageSvc)

Definition: PrecedenceRulesGraph.h:729

Member Data Documentation

◆ m_algoCounter

unsigned int concurrency::PrecedenceRulesGraph::m_algoCounter = 0

private

Total number of algorithm nodes in the graph.

Definition at line 726 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 720 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 714 of file PrecedenceRulesGraph.h.

◆ m_algoNameToAlgoOutputsMap

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

private

Definition at line 721 of file PrecedenceRulesGraph.h.

◆ m_conditionsRealmEnabled

bool concurrency::PrecedenceRulesGraph::m_conditionsRealmEnabled {false}

private

Enable conditions realm of precedence rules.

Definition at line 740 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 718 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 716 of file PrecedenceRulesGraph.h.

◆ m_enableAnalysis

bool concurrency::PrecedenceRulesGraph::m_enableAnalysis {false}

private

Definition at line 735 of file PrecedenceRulesGraph.h.

◆ m_headNode

DecisionNode* concurrency::PrecedenceRulesGraph::m_headNode = nullptr

private

the head node of the control flow graph

Definition at line 712 of file PrecedenceRulesGraph.h.

◆ m_name

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

private

Definition at line 730 of file PrecedenceRulesGraph.h.

◆ m_nodeCounter

unsigned int concurrency::PrecedenceRulesGraph::m_nodeCounter = 0

private

Total number of nodes in the graph.

Definition at line 724 of file PrecedenceRulesGraph.h.

◆ m_prec_trace_map

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

private

Definition at line 734 of file PrecedenceRulesGraph.h.

◆ m_precTrace

precedence::PrecTrace concurrency::PrecedenceRulesGraph::m_precTrace

private

facilities for algorithm precedence tracing

Definition at line 733 of file PrecedenceRulesGraph.h.

◆ m_PRGraph

precedence::PRGraph concurrency::PrecedenceRulesGraph::m_PRGraph

private

BGL-based graph of precedence rules.

Definition at line 737 of file PrecedenceRulesGraph.h.

◆ m_svcLocator

SmartIF<ISvcLocator> concurrency::PrecedenceRulesGraph::m_svcLocator

mutableprivate

Service locator (needed to access the MessageSvc)

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