#include <src/ExecutionFlowGraph.h>

Inheritance diagram for concurrency::AlgorithmNode:

Collaboration diagram for concurrency::AlgorithmNode:

Public Member Functions
	AlgorithmNode (ExecutionFlowGraph &graph, unsigned int nodeIndex, const std::string &algoName, bool inverted, bool allPass)
	Constructor. More...

	~AlgorithmNode ()
	Destructor. More...

virtual void	initialize (const std::unordered_map< std::string, unsigned int > &algname_index_map)
	Initialize. More...

virtual bool	accept (IGraphVisitor &visitor)

void	addParentNode (DecisionNode *node)
	XXX: CF tests. Method to add a parent node. More...

void	addSupplierNode (AlgorithmNode *node)
	Associate an AlgorithmNode, which is a data supplier for this one. More...

void	addConsumerNode (AlgorithmNode *node)
	Associate an AlgorithmNode, which is a data consumer of this one. More...

void	attachAlgorithm (IAlgorithm *ialgo)
	Attach Algorithm representative. More...

const std::vector< IAlgorithm * > &	getAlgorithmRepresentatives () const
	get Algorithm representatives More...

const std::vector< AlgorithmNode * > &	getSupplierNodes () const
	Get all supplier nodes. More...

const std::vector< AlgorithmNode * > &	getConsumerNodes () const
	Get all consumer nodes. More...

void	addOutputDataNode (DataNode *node)
	Associate an AlgorithmNode, which is a data supplier for this one. More...

void	addInputDataNode (DataNode *node)
	Associate an AlgorithmNode, which is a data consumer of this one. More...

const std::vector< DataNode * > &	getOutputDataNodes () const
	Get all supplier nodes. More...

const std::vector< DataNode * > &	getInputDataNodes () const
	Get all consumer nodes. More...

void	setRank (float &rank)
	Set Algorithm rank. More...

const float &	getRank () const
	Get Algorithm rank. More...

const unsigned int &	getAlgoIndex () const
	XXX: CF tests. More...

bool	dataDependenciesSatisfied (const int &slotNum) const
	Method to check whether the Algorithm has its all data dependency satisfied. More...

bool	dataDependenciesSatisfied (AlgsExecutionStates &states) const

virtual int	updateState (AlgsExecutionStates &states, std::vector< int > &node_decisions) const
	Method to set algos to CONTROLREADY, if possible. More...

virtual bool	promoteToControlReadyState (const int &slotNum, AlgsExecutionStates &states, std::vector< int > &node_decisions) const
	XXX: CF tests. More...

bool	promoteToDataReadyState (const int &slotNum, const AlgorithmNode *requestor=nullptr) const

virtual void	updateDecision (const int &slotNum, AlgsExecutionStates &states, std::vector< int > &node_decisions, const AlgorithmNode *requestor=nullptr) const
	XXX: CF tests. More...

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

Public Member Functions inherited from concurrency::ControlFlowNode
	ControlFlowNode (ExecutionFlowGraph &graph, unsigned int nodeIndex, const std::string &name)
	Constructor. More...

virtual	~ControlFlowNode ()
	Destructor. More...

const unsigned int &	getNodeIndex () const
	XXX: CF tests. More...

const std::string &	getNodeName () const

Private Attributes
unsigned int	m_algoIndex
	The index of the algorithm. More...

std::string	m_algoName
	The name of the algorithm. More...

bool	m_inverted
	Whether the selection result is negated or not. More...

bool	m_allPass
	Whether the selection result is relevant or always "pass". More...

std::vector< DecisionNode * >	m_parents
	XXX: CF tests. More...

std::vector< AlgorithmNode * >	m_suppliers
	Vectors, used in data dependencies realm AlgorithmNodes that represent algorithms producing an input needed for the algorithm. More...

std::vector< AlgorithmNode * >	m_consumers
	AlgorithmNodes that represent algorithms which need the output of the algorithm. More...

std::vector< DataNode * >	m_outputs
	Vectors, used in augmented data dependencies realm Outputs of the algorithm, represented as DataNode's. More...

std::vector< DataNode * >	m_inputs
	Inputs of the algorithm, represented as DataNode's. More...

float	m_rank
	Algorithm rank of any kind. More...

std::vector< IAlgorithm * >	m_representatives
	Representatives (including clones) of the node. More...

Additional Inherited Members
Public Attributes inherited from concurrency::ControlFlowNode
ExecutionFlowGraph *	m_graph

Protected Member Functions inherited from concurrency::ControlFlowNode
std::string	stateToString (const int &stateId) const
	Translation between state id and name. More...

Protected Attributes inherited from concurrency::ControlFlowNode
unsigned int	m_nodeIndex

std::string	m_nodeName

Detailed Description

Definition at line 137 of file ExecutionFlowGraph.h.

Constructor & Destructor Documentation

concurrency::AlgorithmNode::AlgorithmNode	(	ExecutionFlowGraph &	graph,
		unsigned int	nodeIndex,
		const std::string &	algoName,
		bool	inverted,
		bool	allPass
	)

inline

Constructor.

Definition at line 140 of file ExecutionFlowGraph.h.

                                                                                                                              :
       ControlFlowNode(graph, nodeIndex, algoName),
       m_algoIndex(0),m_algoName(algoName),m_inverted(inverted),m_allPass(allPass),m_rank(-1)
       {};

concurrency::AlgorithmNode::~AlgorithmNode ( )

Destructor.

Definition at line 194 of file ExecutionFlowGraph.cpp.

                                 {
 
     for (auto node : m_outputs) {
       delete node;
     }
   }

Member Function Documentation

bool concurrency::AlgorithmNode::accept ( IGraphVisitor & visitor )

virtual

Implements concurrency::ControlFlowNode.

Definition at line 367 of file ExecutionFlowGraph.cpp.

                                                    {
 
     if (visitor.visitEnter(*this)) {
       bool result = visitor.visit(*this);
       if (result) return false;
     }
 
     return true;
 
   }

void concurrency::AlgorithmNode::addConsumerNode ( AlgorithmNode * node )

inline

Associate an AlgorithmNode, which is a data consumer of this one.

Definition at line 156 of file ExecutionFlowGraph.h.

156 { m_consumers.push_back(node); }

concurrency::AlgorithmNode::m_consumers

std::vector< AlgorithmNode * > m_consumers

AlgorithmNodes that represent algorithms which need the output of the algorithm.

Definition: ExecutionFlowGraph.h:219

void concurrency::AlgorithmNode::addInputDataNode ( DataNode * node )

Associate an AlgorithmNode, which is a data consumer of this one.

Definition at line 393 of file ExecutionFlowGraph.cpp.

                                                      {
 
     if (std::find(m_inputs.begin(),m_inputs.end(),node) == m_inputs.end())
       m_inputs.push_back(node);
   }

void concurrency::AlgorithmNode::addOutputDataNode ( DataNode * node )

Associate an AlgorithmNode, which is a data supplier for this one.

Definition at line 386 of file ExecutionFlowGraph.cpp.

                                                       {
 
     if (std::find(m_outputs.begin(),m_outputs.end(),node) == m_outputs.end())
       m_outputs.push_back(node);
   }

void concurrency::AlgorithmNode::addParentNode ( DecisionNode * node )

XXX: CF tests. Method to add a parent node.

Definition at line 379 of file ExecutionFlowGraph.cpp.

                                                       {
 
     if (std::find(m_parents.begin(), m_parents.end(), node) == m_parents.end())
       m_parents.push_back(node);
   }

void concurrency::AlgorithmNode::addSupplierNode ( AlgorithmNode * node )

inline

Associate an AlgorithmNode, which is a data supplier for this one.

Definition at line 154 of file ExecutionFlowGraph.h.

154 { m_suppliers.push_back(node); }

concurrency::AlgorithmNode::m_suppliers

std::vector< AlgorithmNode * > m_suppliers

Vectors, used in data dependencies realm AlgorithmNodes that represent algorithms producing an input ...

Definition: ExecutionFlowGraph.h:217

void concurrency::AlgorithmNode::attachAlgorithm ( IAlgorithm * ialgo )

inline

Attach Algorithm representative.

Definition at line 158 of file ExecutionFlowGraph.h.

158 { m_representatives.push_back(ialgo); }

concurrency::AlgorithmNode::m_representatives

std::vector< IAlgorithm * > m_representatives

Representatives (including clones) of the node.

Definition: ExecutionFlowGraph.h:229

bool concurrency::AlgorithmNode::dataDependenciesSatisfied ( const int & slotNum ) const

Method to check whether the Algorithm has its all data dependency satisfied.

Definition at line 262 of file ExecutionFlowGraph.cpp.

                                                                         {
 
     bool result = true;
     auto& states = m_graph->getAlgoStates(slotNum);
 
     for (auto dataNode : m_inputs) {
       result = false;
       for (auto algoNode : dataNode->getProducers())
         if (State::EVTACCEPTED == states[algoNode->getAlgoIndex()]) {
           result = true;
           break;
         }
       if (!result) break;
     }
 
     return result;
   }

bool concurrency::AlgorithmNode::dataDependenciesSatisfied ( AlgsExecutionStates & states ) const

Definition at line 281 of file ExecutionFlowGraph.cpp.

                                                                                  {
 
     bool result = true;
     for (auto dataNode : m_inputs) {
 
       result = false;
       for (auto algoNode : dataNode->getProducers())
         if (State::EVTACCEPTED == states[algoNode->getAlgoIndex()]) {
           result = true;
           break;
         }
 
       if (!result) break;
     }
 
     return result;
   }

const unsigned int& concurrency::AlgorithmNode::getAlgoIndex ( ) const

inline

XXX: CF tests.

Definition at line 180 of file ExecutionFlowGraph.h.

180 { return m_algoIndex; }

concurrency::AlgorithmNode::m_algoIndex

unsigned int m_algoIndex

The index of the algorithm.

Definition: ExecutionFlowGraph.h:205

const std::vector<IAlgorithm*>& concurrency::AlgorithmNode::getAlgorithmRepresentatives ( ) const

inline

get Algorithm representatives

Definition at line 160 of file ExecutionFlowGraph.h.

160 { return m_representatives; }

concurrency::AlgorithmNode::m_representatives

std::vector< IAlgorithm * > m_representatives

Representatives (including clones) of the node.

Definition: ExecutionFlowGraph.h:229

const std::vector<AlgorithmNode*>& concurrency::AlgorithmNode::getConsumerNodes ( ) const

inline

Get all consumer nodes.

Definition at line 164 of file ExecutionFlowGraph.h.

164 {return m_consumers;}

concurrency::AlgorithmNode::m_consumers

std::vector< AlgorithmNode * > m_consumers

AlgorithmNodes that represent algorithms which need the output of the algorithm.

Definition: ExecutionFlowGraph.h:219

const std::vector<DataNode*>& concurrency::AlgorithmNode::getInputDataNodes ( ) const

inline

Get all consumer nodes.

Definition at line 173 of file ExecutionFlowGraph.h.

173 {return m_inputs;}

concurrency::AlgorithmNode::m_inputs

std::vector< DataNode * > m_inputs

Inputs of the algorithm, represented as DataNode's.

Definition: ExecutionFlowGraph.h:225

const std::vector<DataNode*>& concurrency::AlgorithmNode::getOutputDataNodes ( ) const

inline

Get all supplier nodes.

Definition at line 171 of file ExecutionFlowGraph.h.

171 {return m_outputs;}

concurrency::AlgorithmNode::m_outputs

std::vector< DataNode * > m_outputs

Vectors, used in augmented data dependencies realm Outputs of the algorithm, represented as DataNode'...

Definition: ExecutionFlowGraph.h:223

const float& concurrency::AlgorithmNode::getRank ( ) const

inline

Get Algorithm rank.

Definition at line 177 of file ExecutionFlowGraph.h.

177 {return m_rank;}

concurrency::AlgorithmNode::m_rank

float m_rank

Algorithm rank of any kind.

Definition: ExecutionFlowGraph.h:227

const std::vector<AlgorithmNode*>& concurrency::AlgorithmNode::getSupplierNodes ( ) const

inline

Get all supplier nodes.

Definition at line 162 of file ExecutionFlowGraph.h.

162 {return m_suppliers;}

concurrency::AlgorithmNode::m_suppliers

std::vector< AlgorithmNode * > m_suppliers

Vectors, used in data dependencies realm AlgorithmNodes that represent algorithms producing an input ...

Definition: ExecutionFlowGraph.h:217

void concurrency::AlgorithmNode::initialize ( const std::unordered_map< std::string, unsigned int > & algname_index_map )

virtual

Initialize.

Implements concurrency::ControlFlowNode.

Definition at line 202 of file ExecutionFlowGraph.cpp.

                                                                                                   {
 
     m_algoIndex = algname_index_map.at(m_algoName);
   }

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

virtual

Print a string representing the control flow state.

Implements concurrency::ControlFlowNode.

Definition at line 300 of file ExecutionFlowGraph.cpp.

                                                                            {
     output << std::string(recursionLevel, ' ') << m_nodeName << " (" << m_nodeIndex << ")" << ", w/ decision: "
            << stateToString(node_decisions[m_nodeIndex]) << "(" << node_decisions[m_nodeIndex] << ")"
            << ", in state: " << states[m_algoIndex] << std::endl;
   }

bool concurrency::AlgorithmNode::promoteToControlReadyState	(	const int &	slotNum,
		AlgsExecutionStates &	states,
		std::vector< int > &	node_decisions
	)		const

virtual

XXX: CF tests.

Implements concurrency::ControlFlowNode.

Definition at line 208 of file ExecutionFlowGraph.cpp.

                                                                           {
 
     auto& state = states[m_algoIndex];
     bool result = false;
 
     if (State::INITIAL == state) {
       states.updateState(m_algoIndex, State::CONTROLREADY);
       //std::cout << "----> UPDATING ALGORITHM to CONTROLREADY: " << m_algoName << std::endl;
       result = true;
     } else if (State::CONTROLREADY == state) {
       result = true;
     }
 
     return result;
   }

bool concurrency::AlgorithmNode::promoteToDataReadyState	(	const int &	slotNum,
		const AlgorithmNode *	requestor = `nullptr`
	)		const

Definition at line 227 of file ExecutionFlowGraph.cpp.

                                                                                               {
 
     auto& states = m_graph->getAlgoStates(slotNum);
     auto& state = states[m_algoIndex];
     bool result = false;
 
     if (State::CONTROLREADY == state) {
       if (dataDependenciesSatisfied(slotNum)) {
         //std::cout << "----> UPDATING ALGORITHM to DATAREADY: " << m_algoName << std::endl;
         states.updateState(m_algoIndex, State::DATAREADY);
         result = true;
 
         //m_graph->addEdgeToExecutionPlan(requestor, this);
 
         /*
         auto xtime = std::chrono::high_resolution_clock::now();
         std::stringstream s;
         s << getNodeName() << ", "
           << (xtime-m_graph->getInitTime()).count() << "\n";
         std::ofstream myfile;
         myfile.open("DRTiming.csv", std::ios::app);
         myfile << s.str();
         myfile.close();
         */
       }
     } else if (State::DATAREADY == state) {
       result = true;
     } else if (State::SCHEDULED == state) {
       result = true;
     }
 
     return result;
   }

void concurrency::AlgorithmNode::setRank ( float & rank )

inline

Set Algorithm rank.

Definition at line 175 of file ExecutionFlowGraph.h.

175 {m_rank = rank;}

concurrency::AlgorithmNode::m_rank

float m_rank

Algorithm rank of any kind.

Definition: ExecutionFlowGraph.h:227

void concurrency::AlgorithmNode::updateDecision	(	const int &	slotNum,
		AlgsExecutionStates &	states,
		std::vector< int > &	node_decisions,
		const AlgorithmNode *	requestor = `nullptr`
	)		const

virtual

XXX: CF tests.

Implements concurrency::ControlFlowNode.

Definition at line 334 of file ExecutionFlowGraph.cpp.

                                                                            {
 
     const State& state = states[m_algoIndex];
     int decision = -1;
     requestor = this;
 
     // now derive the proper result to pass back
     if (true == m_allPass) {
       decision = 1;
     } else if (State::EVTACCEPTED == state) {
       decision = !m_inverted;
     } else if (State::EVTREJECTED == state) {
       decision = m_inverted;
     } else {
       decision =  -1; // result not known yet
     }
 
     node_decisions[m_nodeIndex] = decision;
 
     if (-1 != decision) {
       for (auto output : m_outputs)
         for (auto consumer : output->getConsumers())
           consumer->promoteToDataReadyState(slotNum, requestor);
 
       for (auto p : m_parents)
         p->updateDecision(slotNum, states, node_decisions, requestor);
     }
   }

int concurrency::AlgorithmNode::updateState	(	AlgsExecutionStates &	states,
		std::vector< int > &	node_decisions
	)		const

virtual

Method to set algos to CONTROLREADY, if possible.

Implements concurrency::ControlFlowNode.

Definition at line 310 of file ExecutionFlowGraph.cpp.

                                                                        {
     // check whether we already had a result earlier
     //    if (-1 != node_decisions[m_nodeIndex] ) { return node_decisions[m_nodeIndex]; }
     // since we reached this point in the control flow, this algorithm is supposed to run
     // if it hasn't already
     const State& state = states[m_algoIndex];
     unsigned int decision = -1;
     if (State::INITIAL == state) {states.updateState(m_algoIndex, State::CONTROLREADY);}
     // now derive the proper result to pass back
     if (true == m_allPass) {
       decision = 1;
     } else if (State::EVTACCEPTED == state) {
       decision = !m_inverted;
     } else if (State::EVTREJECTED == state) {
       decision = m_inverted;
     } else {
       decision =  -1; // result not known yet
     }
     node_decisions[m_nodeIndex] = decision;
     return decision;
   }

Member Data Documentation

unsigned int concurrency::AlgorithmNode::m_algoIndex

private

The index of the algorithm.

Definition at line 205 of file ExecutionFlowGraph.h.

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 207 of file ExecutionFlowGraph.h.

bool concurrency::AlgorithmNode::m_allPass

private

Whether the selection result is relevant or always "pass".

Definition at line 211 of file ExecutionFlowGraph.h.

std::vector<AlgorithmNode*> concurrency::AlgorithmNode::m_consumers

private

AlgorithmNodes that represent algorithms which need the output of the algorithm.

Definition at line 219 of file ExecutionFlowGraph.h.

std::vector<DataNode*> concurrency::AlgorithmNode::m_inputs

private

Inputs of the algorithm, represented as DataNode's.

Definition at line 225 of file ExecutionFlowGraph.h.

bool concurrency::AlgorithmNode::m_inverted

private

Whether the selection result is negated or not.

Definition at line 209 of file ExecutionFlowGraph.h.

std::vector<DataNode*> concurrency::AlgorithmNode::m_outputs

private

Vectors, used in augmented data dependencies realm Outputs of the algorithm, represented as DataNode's.

Definition at line 223 of file ExecutionFlowGraph.h.

std::vector<DecisionNode*> concurrency::AlgorithmNode::m_parents

private

XXX: CF tests.

Definition at line 213 of file ExecutionFlowGraph.h.

float concurrency::AlgorithmNode::m_rank

private

Algorithm rank of any kind.

Definition at line 227 of file ExecutionFlowGraph.h.

std::vector<IAlgorithm*> concurrency::AlgorithmNode::m_representatives

private

Representatives (including clones) of the node.

Definition at line 229 of file ExecutionFlowGraph.h.

std::vector<AlgorithmNode*> concurrency::AlgorithmNode::m_suppliers

private

Vectors, used in data dependencies realm AlgorithmNodes that represent algorithms producing an input needed for the algorithm.

Definition at line 217 of file ExecutionFlowGraph.h.

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation