concurrency::PrecedenceRulesGraph Class Reference

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

Inheritance diagram for concurrency::PrecedenceRulesGraph:

Collaboration diagram for concurrency::PrecedenceRulesGraph:

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

Constructor & Destructor Documentation

PrecedenceRulesGraph()

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

inline

Constructor.

Definition at line 623 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 719 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] ";
      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 591 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 625 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 666 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 673 of file PrecedenceRulesGraph.h.

{ 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 651 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 659 of file PrecedenceRulesGraph.h.

{ return m_nodeCounter; }

getDataNode()

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

inline

Get DataNode by DataObject path using graph index.

Definition at line 637 of file PrecedenceRulesGraph.h.

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

getHeadNode()

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

inline

Get head node.

Definition at line 647 of file PrecedenceRulesGraph.h.

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

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

{ 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 705 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 699 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 693 of file PrecedenceRulesGraph.h.

m_algoNameToAlgoOutputsMap

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

private

Definition at line 700 of file PrecedenceRulesGraph.h.

m_conditionsRealmEnabled

bool concurrency::PrecedenceRulesGraph::m_conditionsRealmEnabled { false }

private

Enable conditions realm of precedence rules.

Definition at line 719 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 697 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 695 of file PrecedenceRulesGraph.h.

m_enableAnalysis

bool concurrency::PrecedenceRulesGraph::m_enableAnalysis { false }

private

Definition at line 714 of file PrecedenceRulesGraph.h.

m_headNode

DecisionNode* concurrency::PrecedenceRulesGraph::m_headNode = nullptr

private

the head node of the control flow graph

Definition at line 691 of file PrecedenceRulesGraph.h.

m_name

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

private

Definition at line 709 of file PrecedenceRulesGraph.h.

m_nodeCounter

unsigned int concurrency::PrecedenceRulesGraph::m_nodeCounter = 0

private

Total number of nodes in the graph.

Definition at line 703 of file PrecedenceRulesGraph.h.

m_prec_trace_map

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

private

Definition at line 713 of file PrecedenceRulesGraph.h.

m_precTrace

precedence::PrecTrace concurrency::PrecedenceRulesGraph::m_precTrace

private

facilities for algorithm precedence tracing

Definition at line 712 of file PrecedenceRulesGraph.h.

m_PRGraph

precedence::PRGraph concurrency::PrecedenceRulesGraph::m_PRGraph

private

BGL-based graph of precedence rules.

Definition at line 716 of file PrecedenceRulesGraph.h.

m_svcLocator

SmartIF<ISvcLocator> concurrency::PrecedenceRulesGraph::m_svcLocator

mutableprivate

Service locator (needed to access the MessageSvc)

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