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...
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...
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...

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
std::vector< EventSlot > *	m_eventSlots
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 280 of file PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

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

inline

Constructor.

Definition at line 284 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 288 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 608 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 652 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 681 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 820 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 718 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 307 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 549 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 496 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::dumpDataFlow

(

)

const

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

Definition at line 776 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 804 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 645 of file PrecedenceRulesGraph.cpp.

  {

    return m_algoNameToAlgoNodeMap.at( algoName );
  }

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

inline

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

{return m_nodeCounter;}

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

(

)

const

Definition at line 761 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 674 of file PrecedenceRulesGraph.cpp.

  {

    return m_dataPathToDataNodeMap.at( dataPath );
  }

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

inline

Definition at line 344 of file PrecedenceRulesGraph.h.

{return m_initTime;}

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

inline

Definition at line 348 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 439 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 452 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 340 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 333 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 747 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 470 of file PrecedenceRulesGraph.cpp.

  {

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

    DataObjIDColl inputObjs, outputObjs;
    DHHVisitor avis( inputObjs, outputObjs );
    algo->acceptDHVisitor( &avis );

    m_algoNameToAlgoInputsMap[algoName] = inputObjs;
    m_algoNameToAlgoOutputsMap[algoName] = outputObjs;

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

      debug() << "Outputs of " << algoName << ": ";
      for (auto tag : outputObjs)
        debug() << tag << " | ";
      debug() << endmsg;
    }
  }

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

inlineoverride

Retrieve pointer to service locator.

Definition at line 342 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 738 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 );
  }

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

XXX CF tests. Is needed for older CF implementation.

Definition at line 732 of file PrecedenceRulesGraph.cpp.

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

Member Data Documentation

friend concurrency::PrecedenceRulesGraph::ExecutionFlowManager

private

Definition at line 281 of file PrecedenceRulesGraph.h.

AlgoInputsMap concurrency::PrecedenceRulesGraph::m_algoNameToAlgoInputsMap

private

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

Definition at line 366 of file PrecedenceRulesGraph.h.

AlgoNodesMap concurrency::PrecedenceRulesGraph::m_algoNameToAlgoNodeMap

private

Index: map of algorithm's name to AlgorithmNode.

Definition at line 360 of file PrecedenceRulesGraph.h.

AlgoOutputsMap concurrency::PrecedenceRulesGraph::m_algoNameToAlgoOutputsMap

private

Definition at line 367 of file PrecedenceRulesGraph.h.

DataNodesMap concurrency::PrecedenceRulesGraph::m_dataPathToDataNodeMap

private

Index: map of data path to DataNode.

Definition at line 364 of file PrecedenceRulesGraph.h.

DecisionHubsMap concurrency::PrecedenceRulesGraph::m_decisionNameToDecisionHubMap

private

Index: map of decision's name to DecisionHub.

Definition at line 362 of file PrecedenceRulesGraph.h.

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

private

Definition at line 375 of file PrecedenceRulesGraph.h.

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

private

Definition at line 378 of file PrecedenceRulesGraph.h.

boost::ExecPlan concurrency::PrecedenceRulesGraph::m_ExecPlan

private

temporary items to experiment with execution planning

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

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

private

Definition at line 373 of file PrecedenceRulesGraph.h.

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

private

Definition at line 372 of file PrecedenceRulesGraph.h.

unsigned int concurrency::PrecedenceRulesGraph::m_nodeCounter

private

Total number of nodes in the graph.

Definition at line 369 of file PrecedenceRulesGraph.h.

SmartIF<ISvcLocator> concurrency::PrecedenceRulesGraph::m_svcLocator

mutableprivate

Service locator (needed to access the MessageSvc)

Definition at line 371 of file PrecedenceRulesGraph.h.

---

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

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