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 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 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
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< IExecutionFlowGraph >
using	base_class = CommonMessaging
Protected Member Functions inherited from CommonMessaging< IExecutionFlowGraph >
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...

Detailed Description

Definition at line 271 of file ExecutionFlowGraph.h.

Constructor & Destructor Documentation

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

inline

Constructor.

Definition at line 275 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 279 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 581 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 DataObjID &

dataPath

)

Add DataNode that represents DataObject.

Definition at line 620 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 647 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 780 of file ExecutionFlowGraph.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 Property& p = alg->getProperty( "AvgRuntime" );
            runtime = std::stof( p.toString() );
          } catch(...) {
            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 Property& p = alg->getProperty( "AvgRuntime" );
          runtime = std::stof( p.toString() );
        } catch(...) {
          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;
    }

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

(

)

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

Definition at line 462 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) {
        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) {
    //        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) {
        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::ExecutionFlowGraph::dumpDataFlow

(

)

const

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

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

(

)

dump to file encountered execution plan

Definition at line 765 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 614 of file ExecutionFlowGraph.cpp.

                                                                                     {

    return m_algoNameToAlgoNodeMap.at(algoName);
  }

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

inline

Definition at line 337 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 312 of file ExecutionFlowGraph.h.

{return m_nodeCounter;}

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

(

)

const

Definition at line 718 of file ExecutionFlowGraph.cpp.

                                                                                    {

    std::vector<AlgorithmNode*> result;

    for (auto node : m_algoNameToAlgoInputsMap) {
      DataObjIDColl 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 DataObjID &

dataPath

)

const

Get DataNode by DataObject path using graph index.

Definition at line 641 of file ExecutionFlowGraph.cpp.

                                                                           {

    return m_dataPathToDataNodeMap.at(dataPath);
  }

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

inline

Definition at line 335 of file ExecutionFlowGraph.h.

{return m_initTime;};

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

inline

Definition at line 339 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 405 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 418 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;

    debug() << dumpDataFlow() << endmsg;

    return sc;
  }

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

inlineoverride

Retrieve name of the service.

Definition at line 331 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 324 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 708 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 435 of file ExecutionFlowGraph.cpp.

                                                                      {

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


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

    m_algoNameToAlgoInputsMap[algoName] = inputObjs;

    debug() << "Inputs of " << algoName << ": ";
    for (auto tag : inputObjs) {
      debug() << tag << " | ";
    }
    debug() << endmsg;

    m_algoNameToAlgoOutputsMap[algoName] = outputObjs;

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

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

inlineoverride

Retrieve pointer to service locator.

Definition at line 333 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 699 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 693 of file ExecutionFlowGraph.cpp.

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

Member Data Documentation

friend concurrency::ExecutionFlowGraph::ExecutionFlowManager

private

Definition at line 272 of file ExecutionFlowGraph.h.

AlgoInputsMap concurrency::ExecutionFlowGraph::m_algoNameToAlgoInputsMap

private

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

Definition at line 357 of file ExecutionFlowGraph.h.

AlgoNodesMap concurrency::ExecutionFlowGraph::m_algoNameToAlgoNodeMap

private

Index: map of algorithm's name to AlgorithmNode.

Definition at line 351 of file ExecutionFlowGraph.h.

AlgoOutputsMap concurrency::ExecutionFlowGraph::m_algoNameToAlgoOutputsMap

private

Definition at line 358 of file ExecutionFlowGraph.h.

DataNodesMap concurrency::ExecutionFlowGraph::m_dataPathToDataNodeMap

private

Index: map of data path to DataNode.

Definition at line 355 of file ExecutionFlowGraph.h.

DecisionHubsMap concurrency::ExecutionFlowGraph::m_decisionNameToDecisionHubMap

private

Index: map of decision's name to DecisionHub.

Definition at line 353 of file ExecutionFlowGraph.h.

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

private

Definition at line 366 of file ExecutionFlowGraph.h.

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

private

Definition at line 369 of file ExecutionFlowGraph.h.

boost::ExecPlan concurrency::ExecutionFlowGraph::m_ExecPlan

private

temporary items to experiment with execution planning

Definition at line 368 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 349 of file ExecutionFlowGraph.h.

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

private

Definition at line 364 of file ExecutionFlowGraph.h.

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

private

Definition at line 363 of file ExecutionFlowGraph.h.

unsigned int concurrency::ExecutionFlowGraph::m_nodeCounter

private

Total number of nodes in the graph.

Definition at line 360 of file ExecutionFlowGraph.h.

SmartIF<ISvcLocator> concurrency::ExecutionFlowGraph::m_svcLocator

mutableprivate

Service locator (needed to access the MessageSvc)

Definition at line 362 of file ExecutionFlowGraph.h.

---

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

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