#include <src/ExecutionFlowGraph.h>

Inheritance diagram for concurrency::AlgorithmNode:

Collaboration diagram for concurrency::AlgorithmNode:

[legend]

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

	~AlgorithmNode ()
	Destructor. More...

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

bool	accept (IGraphVisitor &visitor) override

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

void	setIOBound (bool value)
	Set the I/O-boundness flag. More...

bool	isIOBound () const
	Check if algorithm is I/O-bound. 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

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

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

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

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

void	printState (std::stringstream &output, AlgsExecutionStates &states, const std::vector< int > &node_decisions, const unsigned int &recursionLevel) const override
	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...

bool	m_isIOBound
	If an algorithm is I/O-bound (in the broad sense of Von Neumann bottleneck) 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,
		bool	IOBound
	)

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),m_isIOBound(IOBound)
       {};

concurrency::AlgorithmNode::~AlgorithmNode ( )

Destructor.

Definition at line 207 of file ExecutionFlowGraph.cpp.

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

Member Function Documentation

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

overridevirtual

Implements concurrency::ControlFlowNode.

Definition at line 387 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:223

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

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

Definition at line 413 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 406 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 399 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:221

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

inline

Attach Algorithm representative.

Definition at line 158 of file ExecutionFlowGraph.h.

158 { m_representatives.push_back(ialgo); }

std::vector::push_back

T push_back(T...args)

concurrency::AlgorithmNode::m_representatives

std::vector< IAlgorithm * > m_representatives

Representatives (including clones) of the node.

Definition: ExecutionFlowGraph.h:233

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

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

Definition at line 278 of file ExecutionFlowGraph.cpp.

   {
 
     bool result = true; //return true if an algorithm has no data inputs
     auto& states = m_graph->getAlgoStates( slotNum );
 
     for ( auto dataNode : m_inputs ) {
       // return false if the input has no producers at all (normally this case must be
       // forbidden, and must be invalidated at configuration time)
       result = false;
       for ( auto algoNode : dataNode->getProducers() )
         if ( State::EVTACCEPTED == states[algoNode->getAlgoIndex()] ) {
           result = true;
           break; // skip checking other producers if one was found to be executed
         }
 
       if (!result) break; // skip checking other inputs if this input was not produced yet
     }
 
     return result;
   }

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

Definition at line 301 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:209

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:233

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:223

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:229

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:227

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:231

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:221

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

overridevirtual

Initialize.

Implements concurrency::ControlFlowNode.

Definition at line 216 of file ExecutionFlowGraph.cpp.

   {
 
     m_algoIndex = algname_index_map.at( m_algoName );
   }

bool concurrency::AlgorithmNode::isIOBound ( ) const

inline

Check if algorithm is I/O-bound.

Definition at line 184 of file ExecutionFlowGraph.h.

184 {return m_isIOBound;}

concurrency::AlgorithmNode::m_isIOBound

bool m_isIOBound

If an algorithm is I/O-bound (in the broad sense of Von Neumann bottleneck)

Definition: ExecutionFlowGraph.h:235

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

overridevirtual

Print a string representing the control flow state.

Implements concurrency::ControlFlowNode.

Definition at line 321 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: " << AlgsExecutionStates::stateNames[states[m_algoIndex]] << std::endl;
   }

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

overridevirtual

XXX: CF tests.

Implements concurrency::ControlFlowNode.

Definition at line 223 of file ExecutionFlowGraph.cpp.

   {
 
     auto& state = states[m_algoIndex];
     bool result = false;
 
     if ( State::INITIAL == state ) {
       states.updateState( m_algoIndex, State::CONTROLREADY ).ignore();
       // 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 242 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 ).ignore();
         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::setIOBound ( bool value )

inline

Set the I/O-boundness flag.

Definition at line 182 of file ExecutionFlowGraph.h.

182 { m_isIOBound = value;}

concurrency::AlgorithmNode::m_isIOBound

bool m_isIOBound

If an algorithm is I/O-bound (in the broad sense of Von Neumann bottleneck)

Definition: ExecutionFlowGraph.h:235

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:231

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

overridevirtual

XXX: CF tests.

Implements concurrency::ControlFlowNode.

Definition at line 357 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

overridevirtual

Method to set algos to CONTROLREADY, if possible.

Implements concurrency::ControlFlowNode.

Definition at line 331 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 ).ignore();
     }
     // 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 209 of file ExecutionFlowGraph.h.

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 211 of file ExecutionFlowGraph.h.

bool concurrency::AlgorithmNode::m_allPass

private

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

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

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

private

Inputs of the algorithm, represented as DataNode's.

Definition at line 229 of file ExecutionFlowGraph.h.

bool concurrency::AlgorithmNode::m_inverted

private

Whether the selection result is negated or not.

Definition at line 213 of file ExecutionFlowGraph.h.

bool concurrency::AlgorithmNode::m_isIOBound

private

If an algorithm is I/O-bound (in the broad sense of Von Neumann bottleneck)

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

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

private

XXX: CF tests.

Definition at line 217 of file ExecutionFlowGraph.h.

float concurrency::AlgorithmNode::m_rank

private

Algorithm rank of any kind.

Definition at line 231 of file ExecutionFlowGraph.h.

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

private

Representatives (including clones) of the node.

Definition at line 233 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 221 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