concurrency::PrecedenceRulesGraph Class Reference

#include <src/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...
	~PrecedenceRulesGraph () override
	Destructor. More...
StatusCode	initialize (const std::unordered_map< std::string, unsigned int > &algname_index_map)
	Initialize graph. More...
StatusCode	initialize (const std::unordered_map< std::string, unsigned int > &algname_index_map, std::vector< EventSlot > &eventSlots)
void	registerIODataObjects (const Algorithm *algo)
	Register algorithm in the Data Dependency index. More...
StatusCode	buildDataDependenciesRealm ()
	Build data dependency realm WITHOUT data object nodes: just interconnect algorithm nodes directly. More...
StatusCode	buildAugmentedDataDependenciesRealm ()
	Build data dependency realm WITH data object nodes participating. More...
void	addHeadNode (const std::string &headName, bool modeConcurrent, bool modePromptDecision, bool modeOR, bool allPass)
	Add a node, which has no parents. More...
StatusCode	addAlgorithmNode (Algorithm *daughterAlgo, const std::string &parentName, bool inverted, bool allPass)
	Add algorithm node. More...
template<class T >
void	attachAlgorithmsToNodes (const std::string &algo_name, const T &container)
	Attach pointers to real Algorithms (and their clones) to Algorithm nodes of the graph. More...
AlgorithmNode *	getAlgorithmNode (const std::string &algoName) const
	Get the AlgorithmNode from by algorithm name using graph index. 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...
StatusCode	addDecisionHubNode (Algorithm *daughterAlgo, const std::string &parentName, bool modeConcurrent, bool modePromptDecision, bool modeOR, bool allPass)
	Add a node, which aggregates decisions of direct daughter nodes. More...
unsigned int	getControlFlowNodeCounter () const
	Get total number of graph nodes. More...
void	updateEventState (AlgsExecutionStates &states, std::vector< int > &node_decisions) const
	XXX CF tests. Is needed for older CF implementation. More...
void	updateDecision (const std::string &algo_name, const int &slotNum, AlgsExecutionStates &states, std::vector< int > &node_decisions) const
	A method to update algorithm node decision, and propagate it upwards. More...
void	rankAlgorithms (IGraphVisitor &ranker) const
	Rank Algorithm nodes by the number of data outputs. More...
void	printState (std::stringstream &output, AlgsExecutionStates &states, const std::vector< int > &node_decisions, const unsigned int &recursionLevel) const
	Print a string representing the control flow state. More...
const std::vector< AlgorithmNode * >	getDataIndependentNodes () const
const std::string &	name () const override
	Retrieve name of the service. More...
SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator. More...
const std::chrono::system_clock::time_point	getInitTime () const
AlgsExecutionStates &	getAlgoStates (const int &slotNum) const
std::vector< int > &	getNodeDecisions (const int &slotNum) 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	dumpExecutionPlan ()
	dump to file encountered execution plan More...
void	addEdgeToExecutionPlan (const AlgorithmNode *u, const AlgorithmNode *v)
	set cause-effect connection between two algorithms in the execution plan More...
void	dumpControlFlow (std::ostringstream &, ControlFlowNode *, const int &) const
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor. More...
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...
MSG::Level	msgLevel () const
	get the output level from the embedded MsgStream More...
MSG::Level	outputLevel () const __attribute__((deprecated))
	Backward compatibility function for getting the output level. More...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...

Public Attributes
std::vector< EventSlot > *	m_eventSlots

Private Attributes
friend	ExecutionFlowManager
DecisionNode *	m_headNode
	the head node of the control flow graph; may want to have multiple ones once supporting trigger paths More...
AlgoNodesMap	m_algoNameToAlgoNodeMap
	Index: map of algorithm's name to AlgorithmNode. More...
DecisionHubsMap	m_decisionNameToDecisionHubMap
	Index: map of decision's name to DecisionHub. More...
DataNodesMap	m_dataPathToDataNodeMap
	Index: map of data path to DataNode. More...
AlgoInputsMap	m_algoNameToAlgoInputsMap
	Indexes: maps of algorithm's name to algorithm's inputs/outputs. More...
AlgoOutputsMap	m_algoNameToAlgoOutputsMap
unsigned int	m_nodeCounter
	Total number of nodes in the graph. More...
SmartIF< ISvcLocator >	m_svcLocator
	Service locator (needed to access the MessageSvc) More...
const std::string	m_name
const std::chrono::system_clock::time_point	m_initTime
boost::ExecPlan	m_ExecPlan
	temporary items to experiment with execution planning More...
std::map< std::string, boost::AlgoVertex >	m_exec_plan_map

Additional Inherited Members
Public Types inherited from CommonMessaging< IPrecedenceRulesGraph >
using	base_class = CommonMessaging
Protected Member Functions inherited from CommonMessaging< IPrecedenceRulesGraph >
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...

Detailed Description

Definition at line 293 of file PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

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

inline

Constructor.

Definition at line 297 of file PrecedenceRulesGraph.h.

                                                                          :
     m_headNode(0), m_nodeCounter(0), m_svcLocator(svc), m_name(name), m_initTime(std::chrono::system_clock::now()),
     m_eventSlots(nullptr) {}

concurrency::PrecedenceRulesGraph::~PrecedenceRulesGraph ( )

inlineoverride

Destructor.

Definition at line 301 of file PrecedenceRulesGraph.h.

                                     {
      if (m_headNode != 0) delete m_headNode;
    }

Member Function Documentation

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

Add algorithm node.

Definition at line 588 of file PrecedenceRulesGraph.cpp.

  {

    StatusCode sc = StatusCode::SUCCESS;

    auto& algoName = algo->name();

    auto itP = m_decisionNameToDecisionHubMap.find( parentName );
    concurrency::DecisionNode* parentNode;
    if ( itP != m_decisionNameToDecisionHubMap.end() ) {
      parentNode = itP->second;
      auto itA   = m_algoNameToAlgoNodeMap.find( algoName );
      concurrency::AlgorithmNode* algoNode;
      if ( itA != m_algoNameToAlgoNodeMap.end() ) {
        algoNode = itA->second;
      } else {
        algoNode = new concurrency::AlgorithmNode( *this, m_nodeCounter, algoName, inverted, allPass, algo->isIOBound() );
        ++m_nodeCounter;
        m_algoNameToAlgoNodeMap[algoName] = algoNode;
        if (msgLevel(MSG::DEBUG))
          debug() << "AlgoNode " << algoName << " added @ " << algoNode << endmsg;
        registerIODataObjects(algo);
      }

      parentNode->addDaughterNode( algoNode );
      algoNode->addParentNode( parentNode );
    } else {
      sc = StatusCode::FAILURE;
      error() << "Decision hub node " << parentName << ", requested to be parent, is not registered."
              << endmsg;
    }

    return sc;
  }

StatusCode concurrency::PrecedenceRulesGraph::addDataNode

(

const DataObjID &

dataPath

)

Add DataNode that represents DataObject.

Definition at line 632 of file PrecedenceRulesGraph.cpp.

  {

    StatusCode sc;

    auto itD = m_dataPathToDataNodeMap.find( dataPath );
    concurrency::DataNode* dataNode;
    if ( itD != m_dataPathToDataNodeMap.end() ) {
      dataNode = itD->second;
      sc = StatusCode::SUCCESS;
    } else {
      dataNode                          = new concurrency::DataNode( *this, dataPath );
      m_dataPathToDataNodeMap[dataPath] = dataNode;
      if (msgLevel(MSG::DEBUG))
        debug() << "  DataNode for " << dataPath << " added @ " << dataNode << endmsg;
      sc = StatusCode::SUCCESS;
    }

    return sc;
  }

StatusCode concurrency::PrecedenceRulesGraph::addDecisionHubNode	(	Algorithm *	daughterAlgo,
		const std::string &	parentName,
		bool	modeConcurrent,
		bool	modePromptDecision,
		bool	modeOR,
		bool	allPass
	)

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

Definition at line 661 of file PrecedenceRulesGraph.cpp.

  {

    StatusCode sc = StatusCode::SUCCESS;

    auto& decisionHubName = decisionHubAlgo->name();

    auto itP = m_decisionNameToDecisionHubMap.find( parentName );
    concurrency::DecisionNode* parentNode;
    if ( itP != m_decisionNameToDecisionHubMap.end() ) {
      parentNode = itP->second;
      auto itA   = m_decisionNameToDecisionHubMap.find( decisionHubName );
      concurrency::DecisionNode* decisionHubNode;
      if ( itA != m_decisionNameToDecisionHubMap.end() ) {
        decisionHubNode = itA->second;
      } else {
        decisionHubNode =
            new concurrency::DecisionNode( *this, m_nodeCounter, decisionHubName, modeConcurrent, modePromptDecision, modeOR, allPass);
        ++m_nodeCounter;
        m_decisionNameToDecisionHubMap[decisionHubName] = decisionHubNode;
        if (msgLevel(MSG::DEBUG))
          debug() << "Decision hub node " << decisionHubName << " added @ " << decisionHubNode << endmsg;
      }

      parentNode->addDaughterNode( decisionHubNode );
      decisionHubNode->addParentNode( parentNode );
    } else {
      sc = StatusCode::FAILURE;
      error() << "Decision hub node " << parentName << ", requested to be parent, is not registered."
              << endmsg;
    }

    return sc;
  }

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

set cause-effect connection between two algorithms in the execution plan

Definition at line 841 of file PrecedenceRulesGraph.cpp.

  {

    boost::AlgoVertex source;
    float runtime( 0. );
    if ( u == nullptr ) {
      auto itT = m_exec_plan_map.find( "ENTRY" );
      if ( itT != m_exec_plan_map.end() ) {
        source = itT->second;
      } else {
        source                   = boost::add_vertex( boost::AlgoNodeStruct( "ENTRY", -999, -999, 0 ), m_ExecPlan );
        m_exec_plan_map["ENTRY"] = source;
      }
    } else {
      auto itS = m_exec_plan_map.find( u->getNodeName() );
      if ( itS != m_exec_plan_map.end() ) {
        source = itS->second;
      } else {
        auto alg = dynamic_cast<Algorithm*>( u->getAlgorithmRepresentatives()[0] );
        if ( alg == 0 ) {
          fatal() << "could not convert IAlgorithm to Algorithm!" << endmsg;
        } else {
          try {
            const Gaudi::Details::PropertyBase& p = alg->getProperty( "AvgRuntime" );
            runtime = std::stof( p.toString() );
          } catch(...) {
            if (msgLevel(MSG::DEBUG))
              debug() << "no AvgRuntime for " << alg->name() << endmsg;
            runtime = 1.;
          }
        }
        source = boost::add_vertex( boost::AlgoNodeStruct( u->getNodeName(), u->getAlgoIndex(), u->getRank(), runtime ),
                                    m_ExecPlan );
        m_exec_plan_map[u->getNodeName()] = source;
      }
    }

    boost::AlgoVertex target;
    auto itP = m_exec_plan_map.find( v->getNodeName() );
    if ( itP != m_exec_plan_map.end() ) {
      target = itP->second;
    } else {
      auto alg = dynamic_cast<Algorithm*>( v->getAlgorithmRepresentatives()[0] );
      if ( alg == 0 ) {
        fatal() << "could not convert IAlgorithm to Algorithm!" << endmsg;
      } else {
        try {
          const Gaudi::Details::PropertyBase& p = alg->getProperty( "AvgRuntime" );
          runtime = std::stof( p.toString() );
        } catch(...) {
          if (msgLevel(MSG::DEBUG))
            debug() << "no AvgRuntime for " << alg->name() << endmsg;
          runtime = 1.;
        }
      }
      target = boost::add_vertex( boost::AlgoNodeStruct( v->getNodeName(), v->getAlgoIndex(), v->getRank(), runtime ),
                                  m_ExecPlan );
      m_exec_plan_map[v->getNodeName()] = target;
    }

    if (msgLevel(MSG::DEBUG))
      debug() << "Edge added to execution plan" << endmsg;
    boost::add_edge(source, target, m_ExecPlan);
  }

void concurrency::PrecedenceRulesGraph::addHeadNode	(	const std::string &	headName,
		bool	modeConcurrent,
		bool	modePromptDecision,
		bool	modeOR,
		bool	allPass
	)

Add a node, which has no parents.

Definition at line 698 of file PrecedenceRulesGraph.cpp.

  {

    auto itH = m_decisionNameToDecisionHubMap.find( headName );
    if ( itH != m_decisionNameToDecisionHubMap.end() ) {
      m_headNode = itH->second;
    } else {
      m_headNode = new concurrency::DecisionNode( *this, m_nodeCounter, headName, modeConcurrent, modePromptDecision, modeOR, allPass );
      ++m_nodeCounter;
      m_decisionNameToDecisionHubMap[headName] = m_headNode;
    }
  }

template<class T >

void concurrency::PrecedenceRulesGraph::attachAlgorithmsToNodes ( const std::string &  algo_name, const T &  container  )

inline

Attach pointers to real Algorithms (and their clones) to Algorithm nodes of the graph.

Definition at line 320 of file PrecedenceRulesGraph.h.

                                                                                 {
      auto node = getAlgorithmNode(algo_name);
      for (auto ialgoIt = container.unsafe_begin(); ialgoIt != container.unsafe_end(); ++ialgoIt)
        node->attachAlgorithm(*ialgoIt);
    }

StatusCode concurrency::PrecedenceRulesGraph::buildAugmentedDataDependenciesRealm

(

)

Build data dependency realm WITH data object nodes participating.

Definition at line 529 of file PrecedenceRulesGraph.cpp.

  {

    StatusCode global_sc( StatusCode::SUCCESS, true );

    // Create the DataObjects (DO) realm (represented by DataNodes in the graph),
    // connected to DO producers (AlgorithmNodes)
    for (auto algo : m_algoNameToAlgoNodeMap) {

      auto& outCollection = m_algoNameToAlgoOutputsMap[algo.first];
      for (auto outputTag : outCollection) {
        const auto sc = addDataNode(outputTag);
        if (!sc.isSuccess()) {
          error() << "Extra producer (" << algo.first << ") for DataObject @ "
                  << outputTag
                  << " has been detected: this is not allowed." << endmsg;
          global_sc = sc;
        }
        auto dataNode = getDataNode(outputTag);
        dataNode->addProducerNode(algo.second);
        algo.second->addOutputDataNode(dataNode);
      }
    }

    // Connect previously created DO realm to DO consumers (AlgorithmNodes)
    for ( auto algo : m_algoNameToAlgoNodeMap ) {
      auto& inCollection = m_algoNameToAlgoInputsMap[algo.first];
      for (auto inputTag : inCollection) {
        DataNode* dataNode = nullptr;
        auto primaryPath = inputTag;
        auto itP = m_dataPathToDataNodeMap.find(primaryPath);
        if (itP != m_dataPathToDataNodeMap.end()) {
          dataNode = getDataNode(primaryPath);
          //if (!inCollection[inputTag].alternativeDataProductNames().empty())
          //  warning() << "Dropping all alternative data dependencies in the graph, but '" << primaryPath
          //            << "', for algorithm " << algo.first << endmsg;
          //} else {
          //  for (auto alterPath : inCollection[inputTag].alternativeDataProductNames()) {
          //    auto itAP = m_dataPathToDataNodeMap.find(alterPath);
          //    if (itAP != m_dataPathToDataNodeMap.end()) {
          //      dataNode = getDataNode(alterPath);
          //      warning() << "Dropping all alternative data dependencies in the graph, but '" << alterPath
          //                << "', for algorithm " << algo.first << endmsg;
          //      break;
          //    }
          //}
        }

        if (dataNode) {
          dataNode->addConsumerNode(algo.second);
          algo.second->addInputDataNode(dataNode);
        }
      }
    }

    return global_sc;
  }

StatusCode concurrency::PrecedenceRulesGraph::buildDataDependenciesRealm

(

)

Build data dependency realm WITHOUT data object nodes: just interconnect algorithm nodes directly.

Definition at line 476 of file PrecedenceRulesGraph.cpp.

  {

    StatusCode global_sc( StatusCode::SUCCESS );

    for ( auto algo : m_algoNameToAlgoNodeMap ) {

      auto targetNode = m_algoNameToAlgoNodeMap[algo.first];

      // Find producers for all the inputs of the target node
      auto& targetInCollection = m_algoNameToAlgoInputsMap[algo.first];
      for (auto inputTag : targetInCollection) {
        for (auto producer : m_algoNameToAlgoOutputsMap) {
          auto& outputs = m_algoNameToAlgoOutputsMap[producer.first];
          for (auto outputTag : outputs) {
            if (inputTag == outputTag) {
              auto& known_producers = targetNode->getSupplierNodes();
              auto valid_producer   = m_algoNameToAlgoNodeMap[producer.first];
              auto& known_consumers = valid_producer->getConsumerNodes();
              if ( std::find( known_producers.begin(), known_producers.end(), valid_producer ) ==
                   known_producers.end() )
                targetNode->addSupplierNode( valid_producer );
              if ( std::find( known_consumers.begin(), known_consumers.end(), targetNode ) == known_consumers.end() )
                valid_producer->addConsumerNode( targetNode );
            }
          }
        }
      }

      // Find consumers for all the outputs of the target node
      auto& targetOutCollection = m_algoNameToAlgoOutputsMap[algo.first];
      for (auto outputTag : targetOutCollection) {
        for (auto consumer : m_algoNameToAlgoInputsMap) {
          auto& inputs = m_algoNameToAlgoInputsMap[consumer.first];
          for (auto inputTag : inputs) {
            if (inputTag == outputTag) {
              auto& known_consumers = targetNode->getConsumerNodes();
              auto valid_consumer   = m_algoNameToAlgoNodeMap[consumer.first];
              auto& known_producers = valid_consumer->getSupplierNodes();
              if ( std::find( known_producers.begin(), known_producers.end(), targetNode ) == known_producers.end() )
                valid_consumer->addSupplierNode( targetNode );
              if ( std::find( known_consumers.begin(), known_consumers.end(), valid_consumer ) ==
                   known_consumers.end() )
                targetNode->addConsumerNode( valid_consumer );
            }
          }
        }
      }
    }
    return global_sc;
  }

std::string concurrency::PrecedenceRulesGraph::dumpControlFlow

(

)

const

Print out control flow of Algorithms and Sequences.

Definition at line 758 of file PrecedenceRulesGraph.cpp.

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

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

Definition at line 764 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->getNodeName() << " [Seq] ";
        ost << ( (dn->m_modeConcurrent) ? " [Concurrent] " : " [Sequential] " );
        ost << ( (dn->m_modePromptDecision) ? " [Prompt] " : "" );
        ost << ( (dn->m_modeOR) ? " [OR] " : "" );
        ost << ( (dn->m_allPass) ? " [PASS] " : "" );
        ost << "\n";
      }
      const std::vector<ControlFlowNode*>& dth = dn->getDaughters();
      for (std::vector<ControlFlowNode*>::const_iterator itr= dth.begin();
           itr != dth.end(); ++itr) {      
        dumpControlFlow(ost,*itr,indent+1);
      }
    } else if (an != 0) {
      ost << node->getNodeName() << " [Alg] ";
      if (an != 0) {
        auto ar = an->getAlgorithmRepresentatives();
        ost << " [n= " << ar.at(0)->cardinality() << "]";
        ost << ( (! ar.at(0)->isClonable()) ? " [unclonable] " : "" );
      }
      ost << "\n";
    }

  }

std::string concurrency::PrecedenceRulesGraph::dumpDataFlow

(

)

const

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

Definition at line 797 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->getNodeName() << "\n";

      ost << idt << "  V\n";
      ost << idt << "  o " << pair.first << "\n";
      ost << idt << "  V\n";

      for ( auto algoNode : pair.second->getConsumers() ) ost << idt << "  " << algoNode->getNodeName() << "\n";

      ost << idt << "====================================\n";
    }

    return ost.str();
  }

void concurrency::PrecedenceRulesGraph::dumpExecutionPlan

(

)

dump to file encountered execution plan

Definition at line 825 of file PrecedenceRulesGraph.cpp.

  {
    std::ofstream myfile;
    myfile.open( "ExecutionPlan.graphml", std::ios::app );

    boost::dynamic_properties dp;
    dp.property( "name", boost::get( &boost::AlgoNodeStruct::m_name, m_ExecPlan ) );
    dp.property( "index", boost::get( &boost::AlgoNodeStruct::m_index, m_ExecPlan ) );
    dp.property( "rank", boost::get( &boost::AlgoNodeStruct::m_rank, m_ExecPlan ) );
    dp.property( "runtime", boost::get( &boost::AlgoNodeStruct::m_runtime, m_ExecPlan ) );

    boost::write_graphml( myfile, m_ExecPlan, dp );

    myfile.close();
  }

AlgorithmNode * concurrency::PrecedenceRulesGraph::getAlgorithmNode

(

const std::string &

algoName

)

const

Get the AlgorithmNode from by algorithm name using graph index.

Definition at line 625 of file PrecedenceRulesGraph.cpp.

  {

    return m_algoNameToAlgoNodeMap.at( algoName );
  }

AlgsExecutionStates& concurrency::PrecedenceRulesGraph::getAlgoStates ( const int &  slotNum ) const

inline

Definition at line 359 of file PrecedenceRulesGraph.h.

{return m_eventSlots->at(slotNum).algsStates;}

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

inline

Get total number of graph nodes.

Definition at line 334 of file PrecedenceRulesGraph.h.

{return m_nodeCounter;}

const std::vector< AlgorithmNode * > concurrency::PrecedenceRulesGraph::getDataIndependentNodes

(

)

const

Definition at line 744 of file PrecedenceRulesGraph.cpp.

  {

    std::vector<AlgorithmNode*> result;

    for (auto node : m_algoNameToAlgoInputsMap) {
      DataObjIDColl collection = (node.second);
      if (collection.empty())
        result.push_back(getAlgorithmNode(node.first));
    }

    return result;
  }

DataNode * concurrency::PrecedenceRulesGraph::getDataNode

(

const DataObjID &

dataPath

)

const

Get DataNode by DataObject path using graph index.

Definition at line 654 of file PrecedenceRulesGraph.cpp.

  {

    return m_dataPathToDataNodeMap.at( dataPath );
  }

const std::chrono::system_clock::time_point concurrency::PrecedenceRulesGraph::getInitTime ( ) const

inline

Definition at line 357 of file PrecedenceRulesGraph.h.

{return m_initTime;}

std::vector<int>& concurrency::PrecedenceRulesGraph::getNodeDecisions ( const int &  slotNum ) const

inline

Definition at line 361 of file PrecedenceRulesGraph.h.

{return m_eventSlots->at(slotNum).controlFlowState;}

StatusCode concurrency::PrecedenceRulesGraph::initialize

(

const std::unordered_map< std::string, unsigned int > &

algname_index_map

)

Initialize graph.

Definition at line 423 of file PrecedenceRulesGraph.cpp.

  {

    m_headNode->initialize( algname_index_map );
    // StatusCode sc = buildDataDependenciesRealm();
    StatusCode sc = buildAugmentedDataDependenciesRealm();

    if ( !sc.isSuccess() ) error() << "Could not build the data dependency realm." << endmsg;

    return sc;
  }

StatusCode concurrency::PrecedenceRulesGraph::initialize	(	const std::unordered_map< std::string, unsigned int > &	algname_index_map,
		std::vector< EventSlot > &	eventSlots
	)

Definition at line 436 of file PrecedenceRulesGraph.cpp.

  {

    m_eventSlots = &eventSlots;
    m_headNode->initialize( algname_index_map );
    // StatusCode sc = buildDataDependenciesRealm();
    StatusCode sc = buildAugmentedDataDependenciesRealm();

    if ( !sc.isSuccess() ) error() << "Could not build the data dependency realm." << endmsg;

    if (msgLevel(MSG::DEBUG))
      debug() << dumpDataFlow() << endmsg;

    return sc;
  }

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

inlineoverride

Retrieve name of the service.

Definition at line 353 of file PrecedenceRulesGraph.h.

{return m_name;}

void concurrency::PrecedenceRulesGraph::printState ( std::stringstream &  output, AlgsExecutionStates &  states, const std::vector< int > &  node_decisions, const unsigned int &  recursionLevel  ) const

inline

Print a string representing the control flow state.

Definition at line 346 of file PrecedenceRulesGraph.h.

                                                              {m_headNode->printState(output,states,node_decisions,recursionLevel);}

void concurrency::PrecedenceRulesGraph::rankAlgorithms

(

IGraphVisitor &

ranker

)

const

Rank Algorithm nodes by the number of data outputs.

Definition at line 730 of file PrecedenceRulesGraph.cpp.

  {

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

void concurrency::PrecedenceRulesGraph::registerIODataObjects

(

const Algorithm *

algo

)

Register algorithm in the Data Dependency index.

Definition at line 454 of file PrecedenceRulesGraph.cpp.

  {

    const std::string& algoName = algo->name();

    m_algoNameToAlgoInputsMap[algoName] = algo->inputDataObjs();
    m_algoNameToAlgoOutputsMap[algoName] = algo->outputDataObjs();

    if (msgLevel(MSG::DEBUG)) {
      debug() << "Inputs of " << algoName << ": ";
      for (auto tag : algo->inputDataObjs())
        debug() << tag << " | ";
      debug() << endmsg;

      debug() << "Outputs of " << algoName << ": ";
      for (auto tag : algo->outputDataObjs())
        debug() << tag << " | ";
      debug() << endmsg;
    }
  }

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

inlineoverride

Retrieve pointer to service locator.

Definition at line 355 of file PrecedenceRulesGraph.h.

{return m_svcLocator;}

void concurrency::PrecedenceRulesGraph::updateDecision	(	const std::string &	algo_name,
		const int &	slotNum,
		AlgsExecutionStates &	states,
		std::vector< int > &	node_decisions
	)		const

A method to update algorithm node decision, and propagate it upwards.

Definition at line 718 of file PrecedenceRulesGraph.cpp.

  {
    //if (msgLevel(MSG::DEBUG))
    //  debug() << "(UPDATING)Setting decision of algorithm " << algo_name << " and propagating it upwards.." << endmsg;
    //getAlgorithmNode( algo_name )->updateDecision( slotNum, algo_states, node_decisions );
    auto& slot = (*m_eventSlots)[slotNum];
    auto updater = DecisionUpdater(slot);
    getAlgorithmNode( algo_name )->accept(updater);
  }

void concurrency::PrecedenceRulesGraph::updateEventState	(	AlgsExecutionStates &	states,
		std::vector< int > &	node_decisions
	)		const

XXX CF tests. Is needed for older CF implementation.

Definition at line 712 of file PrecedenceRulesGraph.cpp.

  {
    m_headNode->updateState( algo_states, node_decisions );
  }

Member Data Documentation

friend concurrency::PrecedenceRulesGraph::ExecutionFlowManager

private

Definition at line 294 of file PrecedenceRulesGraph.h.

AlgoInputsMap concurrency::PrecedenceRulesGraph::m_algoNameToAlgoInputsMap

private

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

Definition at line 381 of file PrecedenceRulesGraph.h.

AlgoNodesMap concurrency::PrecedenceRulesGraph::m_algoNameToAlgoNodeMap

private

Index: map of algorithm's name to AlgorithmNode.

Definition at line 375 of file PrecedenceRulesGraph.h.

AlgoOutputsMap concurrency::PrecedenceRulesGraph::m_algoNameToAlgoOutputsMap

private

Definition at line 382 of file PrecedenceRulesGraph.h.

DataNodesMap concurrency::PrecedenceRulesGraph::m_dataPathToDataNodeMap

private

Index: map of data path to DataNode.

Definition at line 379 of file PrecedenceRulesGraph.h.

DecisionHubsMap concurrency::PrecedenceRulesGraph::m_decisionNameToDecisionHubMap

private

Index: map of decision's name to DecisionHub.

Definition at line 377 of file PrecedenceRulesGraph.h.

std::vector<EventSlot>* concurrency::PrecedenceRulesGraph::m_eventSlots

Definition at line 393 of file PrecedenceRulesGraph.h.

std::map<std::string,boost::AlgoVertex> concurrency::PrecedenceRulesGraph::m_exec_plan_map

private

Definition at line 391 of file PrecedenceRulesGraph.h.

boost::ExecPlan concurrency::PrecedenceRulesGraph::m_ExecPlan

private

temporary items to experiment with execution planning

Definition at line 390 of file PrecedenceRulesGraph.h.

DecisionNode* concurrency::PrecedenceRulesGraph::m_headNode

private

the head node of the control flow graph; may want to have multiple ones once supporting trigger paths

Definition at line 373 of file PrecedenceRulesGraph.h.

const std::chrono::system_clock::time_point concurrency::PrecedenceRulesGraph::m_initTime

private

Definition at line 388 of file PrecedenceRulesGraph.h.

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

private

Definition at line 387 of file PrecedenceRulesGraph.h.

unsigned int concurrency::PrecedenceRulesGraph::m_nodeCounter

private

Total number of nodes in the graph.

Definition at line 384 of file PrecedenceRulesGraph.h.

SmartIF<ISvcLocator> concurrency::PrecedenceRulesGraph::m_svcLocator

mutableprivate

Service locator (needed to access the MessageSvc)

Definition at line 386 of file PrecedenceRulesGraph.h.

---

The documentation for this class was generated from the following files:

• GaudiHive/src/PrecedenceRulesGraph.h
• GaudiHive/src/PrecedenceRulesGraph.cpp