concurrency::ExecutionFlowGraph Class Reference

#include <src/ExecutionFlowGraph.h>

Inheritance diagram for concurrency::ExecutionFlowGraph:

Collaboration diagram for concurrency::ExecutionFlowGraph:

Public Member Functions
	ExecutionFlowGraph (const std::string &name, SmartIF< ISvcLocator > svc)
	Constructor. More...
	~ExecutionFlowGraph () 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 modeOR, bool allPass, bool isLazy)
	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 std::string &dataPath)
	Add DataNode that represents DataObject. More...
DataNode *	getDataNode (const std::string &dataPath) const
	Get DataNode by DataObject path using graph index. More...
StatusCode	addDecisionHubNode (Algorithm *daughterAlgo, const std::string &parentName, bool modeOR, bool allPass, bool isLazy)
	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
void	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 CommonMessaging< IExecutionFlowGraph >
	~CommonMessaging () override=default
	Virtual destructor. More...
	~CommonMessaging () override=default
	Virtual destructor. More...
SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service. 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 &	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 &	always () const
	shortcut for the method msgStream(MSG::ALWAYS) More...
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL) More...
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL) More...
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	error () 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 &	warning () const
	shortcut for the method msgStream(MSG::WARNING) More...
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO) More...
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO) More...
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG) More...
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG) More...
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE) More...
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE) More...
MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO) 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...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...
MSG::Level	msgLevel () const
	get the output level from the embedded MsgStream 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< IExecutionFlowGraph >
using	base_class = CommonMessaging
using	base_class = CommonMessaging
Protected Member Functions inherited from CommonMessaging< IExecutionFlowGraph >
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...
Protected Attributes inherited from CommonMessaging< IExecutionFlowGraph >
SmartIF< IMessageSvc >	m_msgsvc
	Pointer to the message service;. More...
std::unique_ptr< MsgStream >	m_msgStream
	The predefined message stream. More...
bool	m_streamWithService
	Flag to create a new MsgStream if it was created without the message service. More...

Detailed Description

Definition at line 270 of file ExecutionFlowGraph.h.

Constructor & Destructor Documentation

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

inline

Constructor.

Definition at line 274 of file ExecutionFlowGraph.h.

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

concurrency::ExecutionFlowGraph::~ExecutionFlowGraph ( )

inlineoverride

Destructor.

Definition at line 278 of file ExecutionFlowGraph.h.

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

Member Function Documentation

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

Add algorithm node.

Definition at line 573 of file ExecutionFlowGraph.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);
        ++m_nodeCounter;
        m_algoNameToAlgoNodeMap[algoName] = algoNode;
        debug() << "AlgoNode " << algoName << " added @ " << algoNode << endmsg;
        registerIODataObjects(algo);
      }

      parentNode->addDaughterNode(algoNode);
      algoNode->addParentNode(parentNode);
    } else {
      sc = StatusCode::FAILURE;
      error() << "DecisionHubNode " << parentName << ", meant to be used as parent, is not registered in the EFG." << endmsg;
    }

    return sc;
  }

StatusCode concurrency::ExecutionFlowGraph::addDataNode

(

const std::string &

dataPath

)

Add DataNode that represents DataObject.

Definition at line 612 of file ExecutionFlowGraph.cpp.

                                                                      {

    StatusCode sc;

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

    return sc;
  }

StatusCode concurrency::ExecutionFlowGraph::addDecisionHubNode	(	Algorithm *	daughterAlgo,
		const std::string &	parentName,
		bool	modeOR,
		bool	allPass,
		bool	isLazy
	)

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

Definition at line 639 of file ExecutionFlowGraph.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,modeOR,allPass,isLazy);
        ++m_nodeCounter;
        m_decisionNameToDecisionHubMap[decisionHubName] = decisionHubNode;
        debug() << "DecisionHubNode " << decisionHubName << " added @ " << decisionHubNode << endmsg;
      }

      parentNode->addDaughterNode(decisionHubNode);
      decisionHubNode->addParentNode(parentNode);
    } else {
      sc = StatusCode::FAILURE;
      error() << "DecisionHubNode " << parentName << ", meant to be used as parent, is not registered in the EFG." << endmsg;
    }

   return sc;
  }

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

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

Definition at line 764 of file ExecutionFlowGraph.cpp.

                                                                                                {

    boost::AlgoVertex source;
    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 cruncher = dynamic_cast<CPUCruncher*> ( u->getAlgorithmRepresentatives()[0] );
        if (!cruncher) fatal() << "Conversion from IAlgorithm to CPUCruncher failed" << endmsg;
        source = boost::add_vertex(boost::AlgoNodeStruct(u->getNodeName(),u->getAlgoIndex(),u->getRank(),cruncher->get_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 cruncher = dynamic_cast<CPUCruncher*> ( v->getAlgorithmRepresentatives()[0] );
      if (!cruncher) fatal() << "Conversion from IAlgorithm to CPUCruncher failed" << endmsg;
      target = boost::add_vertex(boost::AlgoNodeStruct(v->getNodeName(),v->getAlgoIndex(),v->getRank(),cruncher->get_runtime()), m_ExecPlan);
      m_exec_plan_map[v->getNodeName()] = target;
    }

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

void concurrency::ExecutionFlowGraph::addHeadNode	(	const std::string &	headName,
		bool	modeOR,
		bool	allPass,
		bool	isLazy
	)

Add a node, which has no parents.

Definition at line 671 of file ExecutionFlowGraph.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,modeOR,allPass,isLazy);
      ++m_nodeCounter;
      m_decisionNameToDecisionHubMap[headName] = m_headNode;
    }

  }

template<class T >

void concurrency::ExecutionFlowGraph::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 297 of file ExecutionFlowGraph.h.

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

StatusCode concurrency::ExecutionFlowGraph::buildAugmentedDataDependenciesRealm

(

)

Build data dependency realm WITH data object nodes participating.

Definition at line 511 of file ExecutionFlowGraph.cpp.

                                                                     {

    StatusCode global_sc(StatusCode::SUCCESS);

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

      StatusCode sc;
      auto& outCollection = *m_algoNameToAlgoOutputsMap[algo.first];
      for (auto outputTag : outCollection) {
        if (outCollection[outputTag].isValid()) {
          auto& output = outCollection[outputTag].dataProductName();
          sc = addDataNode(output);
          if (!sc.isSuccess()) {
            error() << "Extra producer (" << algo.first << ") for DataObject @ " << output
                    << " has been detected: this is not allowed." << endmsg;
            global_sc = StatusCode::FAILURE;
          }
          auto dataNode = getDataNode(output);
          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) {
        if (inCollection[inputTag].isValid()) {
          DataNode* dataNode = nullptr;
          auto& primaryPath = inCollection[inputTag].dataProductName();
          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::ExecutionFlowGraph::buildDataDependenciesRealm

(

)

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

Definition at line 458 of file ExecutionFlowGraph.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) {
        auto& input2Match = targetInCollection[inputTag].dataProductName();
        for (auto producer : m_algoNameToAlgoOutputsMap) {
          auto& outputs = *m_algoNameToAlgoOutputsMap[producer.first];
          for (auto outputTag : outputs) {
            if (outputs[outputTag].isValid() && outputs[outputTag].dataProductName() == input2Match) {
              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) {
        auto& output2Match = targetOutCollection[outputTag].dataProductName();
        for (auto consumer : m_algoNameToAlgoInputsMap) {
          auto& inputs = *m_algoNameToAlgoInputsMap[consumer.first];
          for (auto inputTag : inputs) {
            if (inputs[inputTag].isValid() && inputs[inputTag].dataProductName() == output2Match) {
              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;
  }

void concurrency::ExecutionFlowGraph::dumpDataFlow

(

)

const

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

Definition at line 727 of file ExecutionFlowGraph.cpp.

                                              {

    debug() << "====================================" << endmsg;
    debug() << "Data origins and destinations:" << endmsg;
    debug() << "====================================" << endmsg;

    for (auto& pair : m_dataPathToDataNodeMap) {

      for (auto algoNode : pair.second->getProducers())
        debug() << "  " << algoNode->getNodeName() << endmsg;

      debug() << "  V" << endmsg;
      debug() << "  o " << pair.first << endmsg;
      debug() << "  V" << endmsg;

      for (auto algoNode : pair.second->getConsumers())
        debug() << "  " << algoNode->getNodeName() << endmsg;

      debug() << "  ====================================" << endmsg;
    }
  }

void concurrency::ExecutionFlowGraph::dumpExecutionPlan

(

)

dump to file encountered execution plan

Definition at line 749 of file ExecutionFlowGraph.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::ExecutionFlowGraph::getAlgorithmNode

(

const std::string &

algoName

)

const

Get the AlgorithmNode from by algorithm name using graph index.

Definition at line 606 of file ExecutionFlowGraph.cpp.

                                                                                     {

    return m_algoNameToAlgoNodeMap.at(algoName);
  }

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

inline

Definition at line 336 of file ExecutionFlowGraph.h.

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

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

inline

Get total number of graph nodes.

Definition at line 311 of file ExecutionFlowGraph.h.

{return m_nodeCounter;}

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

(

)

const

Definition at line 710 of file ExecutionFlowGraph.cpp.

                                                                                    {

    std::vector<AlgorithmNode*> result;

    for (auto node : m_algoNameToAlgoInputsMap) {
      const DataObjectDescriptorCollection& collection = *(node.second);
      for (auto tag : collection)
        if (collection[tag].isValid()) {
          result.push_back(getAlgorithmNode(node.first));
          break;
        }
    }

    return result;
  }

DataNode * concurrency::ExecutionFlowGraph::getDataNode

(

const std::string &

dataPath

)

const

Get DataNode by DataObject path using graph index.

Definition at line 633 of file ExecutionFlowGraph.cpp.

                                                                           {

    return m_dataPathToDataNodeMap.at(dataPath);
  }

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

inline

Definition at line 334 of file ExecutionFlowGraph.h.

{return m_initTime;};

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

inline

Definition at line 338 of file ExecutionFlowGraph.h.

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

StatusCode concurrency::ExecutionFlowGraph::initialize

(

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

algname_index_map

)

Initialize graph.

Definition at line 400 of file ExecutionFlowGraph.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::ExecutionFlowGraph::initialize	(	const std::unordered_map< std::string, unsigned int > &	algname_index_map,
		std::vector< EventSlot > &	eventSlots
	)

Definition at line 413 of file ExecutionFlowGraph.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)) {
      dumpDataFlow();
    }

    return sc;
  }

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

inlineoverride

Retrieve name of the service.

Definition at line 330 of file ExecutionFlowGraph.h.

{return m_name;}

void concurrency::ExecutionFlowGraph::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 323 of file ExecutionFlowGraph.h.

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

void concurrency::ExecutionFlowGraph::rankAlgorithms

(

IGraphVisitor &

ranker

)

const

Rank Algorithm nodes by the number of data outputs.

Definition at line 700 of file ExecutionFlowGraph.cpp.

                                                                     {

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

void concurrency::ExecutionFlowGraph::registerIODataObjects

(

const Algorithm *

algo

)

Register algorithm in the Data Dependency index.

Definition at line 432 of file ExecutionFlowGraph.cpp.

                                                                      {

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

    const DataObjectDescriptorCollection& inputDOCollection = algo->inputDataObjects();
    m_algoNameToAlgoInputsMap[algoName] = &inputDOCollection;

    debug() << "Inputs of " << algoName << ": ";
    for (auto tag : inputDOCollection) {
      if (inputDOCollection[tag].isValid())
        debug() << inputDOCollection[tag].dataProductName() << " | ";
    }
    debug() << endmsg;

    const DataObjectDescriptorCollection& outputDOCollection = algo->outputDataObjects();
    m_algoNameToAlgoOutputsMap[algoName] = &outputDOCollection;

    debug() << "Outputs of " << algoName << ": ";
    for (auto tag : outputDOCollection) {
      if (outputDOCollection[tag].isValid())
        debug() << outputDOCollection[tag].dataProductName() << " | ";
    }
    debug() << endmsg;
  }

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

inlineoverride

Retrieve pointer to service locator.

Definition at line 332 of file ExecutionFlowGraph.h.

{return m_svcLocator;}

void concurrency::ExecutionFlowGraph::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 691 of file ExecutionFlowGraph.cpp.

                                                                              {
    //debug() << "(UPDATING)Setting decision of algorithm " << algo_name << " and propagating it upwards.." << endmsg;
    getAlgorithmNode(algo_name)->updateDecision(slotNum, algo_states, node_decisions);
  }

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

XXX CF tests. Is needed for older CF implementation.

Definition at line 685 of file ExecutionFlowGraph.cpp.

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

Member Data Documentation

friend concurrency::ExecutionFlowGraph::ExecutionFlowManager

private

Definition at line 271 of file ExecutionFlowGraph.h.

AlgoInputsMap concurrency::ExecutionFlowGraph::m_algoNameToAlgoInputsMap

private

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

Definition at line 356 of file ExecutionFlowGraph.h.

AlgoNodesMap concurrency::ExecutionFlowGraph::m_algoNameToAlgoNodeMap

private

Index: map of algorithm's name to AlgorithmNode.

Definition at line 350 of file ExecutionFlowGraph.h.

AlgoOutputsMap concurrency::ExecutionFlowGraph::m_algoNameToAlgoOutputsMap

private

Definition at line 357 of file ExecutionFlowGraph.h.

DataNodesMap concurrency::ExecutionFlowGraph::m_dataPathToDataNodeMap

private

Index: map of data path to DataNode.

Definition at line 354 of file ExecutionFlowGraph.h.

DecisionHubsMap concurrency::ExecutionFlowGraph::m_decisionNameToDecisionHubMap

private

Index: map of decision's name to DecisionHub.

Definition at line 352 of file ExecutionFlowGraph.h.

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

private

Definition at line 365 of file ExecutionFlowGraph.h.

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

private

Definition at line 368 of file ExecutionFlowGraph.h.

boost::ExecPlan concurrency::ExecutionFlowGraph::m_ExecPlan

private

temporary items to experiment with execution planning

Definition at line 367 of file ExecutionFlowGraph.h.

DecisionNode* concurrency::ExecutionFlowGraph::m_headNode

private

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

Definition at line 348 of file ExecutionFlowGraph.h.

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

private

Definition at line 363 of file ExecutionFlowGraph.h.

const std::string concurrency::ExecutionFlowGraph::m_name

private

Definition at line 362 of file ExecutionFlowGraph.h.

unsigned int concurrency::ExecutionFlowGraph::m_nodeCounter

private

Total number of nodes in the graph.

Definition at line 359 of file ExecutionFlowGraph.h.

SmartIF<ISvcLocator> concurrency::ExecutionFlowGraph::m_svcLocator

mutableprivate

Service locator (needed to access the MessageSvc)

Definition at line 361 of file ExecutionFlowGraph.h.

---

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

• GaudiHive/src/ExecutionFlowGraph.h
• GaudiHive/src/ExecutionFlowGraph.cpp