#include <src/PrecedenceRulesGraph.h>

Inheritance diagram for concurrency::AlgorithmNode:

Collaboration diagram for concurrency::AlgorithmNode:

[legend]

Public Member Functions
	AlgorithmNode (PrecedenceRulesGraph &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 (PrecedenceRulesGraph &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
PrecedenceRulesGraph *	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 140 of file PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

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

inline

Constructor.

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

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

Member Function Documentation

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

overridevirtual

Implements concurrency::ControlFlowNode.

Definition at line 406 of file PrecedenceRulesGraph.cpp.

   {
 
     if ( visitor.visitEnter( *this ) ) {
       visitor.visit( *this );
       return true; // visitor was accepted to promote the algorithm
     }
 
     return false; // visitor was rejected (since the algorithm already produced a decision)
   }

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

inline

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

Definition at line 159 of file PrecedenceRulesGraph.h.

159 { 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: PrecedenceRulesGraph.h:226

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

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

Definition at line 432 of file PrecedenceRulesGraph.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 425 of file PrecedenceRulesGraph.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 418 of file PrecedenceRulesGraph.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 157 of file PrecedenceRulesGraph.h.

157 { 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: PrecedenceRulesGraph.h:224

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

inline

Attach Algorithm representative.

Definition at line 161 of file PrecedenceRulesGraph.h.

161 { 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: PrecedenceRulesGraph.h:236

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

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

Definition at line 292 of file PrecedenceRulesGraph.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 315 of file PrecedenceRulesGraph.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 183 of file PrecedenceRulesGraph.h.

183 { return m_algoIndex; }

concurrency::AlgorithmNode::m_algoIndex

unsigned int m_algoIndex

The index of the algorithm.

Definition: PrecedenceRulesGraph.h:212

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

inline

get Algorithm representatives

Definition at line 163 of file PrecedenceRulesGraph.h.

163 { return m_representatives; }

concurrency::AlgorithmNode::m_representatives

std::vector< IAlgorithm * > m_representatives

Representatives (including clones) of the node.

Definition: PrecedenceRulesGraph.h:236

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

inline

Get all consumer nodes.

Definition at line 167 of file PrecedenceRulesGraph.h.

167 {return m_consumers;}

concurrency::AlgorithmNode::m_consumers

std::vector< AlgorithmNode * > m_consumers

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

Definition: PrecedenceRulesGraph.h:226

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

inline

Get all consumer nodes.

Definition at line 176 of file PrecedenceRulesGraph.h.

176 {return m_inputs;}

concurrency::AlgorithmNode::m_inputs

std::vector< DataNode * > m_inputs

Inputs of the algorithm, represented as DataNode's.

Definition: PrecedenceRulesGraph.h:232

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

inline

Get all supplier nodes.

Definition at line 174 of file PrecedenceRulesGraph.h.

174 {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: PrecedenceRulesGraph.h:230

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

inline

Get Algorithm rank.

Definition at line 180 of file PrecedenceRulesGraph.h.

180 {return m_rank;}

concurrency::AlgorithmNode::m_rank

float m_rank

Algorithm rank of any kind.

Definition: PrecedenceRulesGraph.h:234

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

inline

Get all supplier nodes.

Definition at line 165 of file PrecedenceRulesGraph.h.

165 {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: PrecedenceRulesGraph.h:224

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

overridevirtual

Initialize.

Implements concurrency::ControlFlowNode.

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

187 {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: PrecedenceRulesGraph.h:238

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 335 of file PrecedenceRulesGraph.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 237 of file PrecedenceRulesGraph.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 256 of file PrecedenceRulesGraph.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 185 of file PrecedenceRulesGraph.h.

185 { 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: PrecedenceRulesGraph.h:238

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

inline

Set Algorithm rank.

Definition at line 178 of file PrecedenceRulesGraph.h.

178 {m_rank = rank;}

concurrency::AlgorithmNode::m_rank

float m_rank

Algorithm rank of any kind.

Definition: PrecedenceRulesGraph.h:234

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 371 of file PrecedenceRulesGraph.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 );
 
       auto vis = concurrency::Supervisor( slotNum );
       for ( auto p : m_parents ) {
         //p->updateDecision( slotNum, states, node_decisions, requestor );
         p->accept(vis);
       }
 
     }
   }

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 345 of file PrecedenceRulesGraph.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 212 of file PrecedenceRulesGraph.h.

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 214 of file PrecedenceRulesGraph.h.

bool concurrency::AlgorithmNode::m_allPass

private

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

Definition at line 218 of file PrecedenceRulesGraph.h.

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

private

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

Definition at line 226 of file PrecedenceRulesGraph.h.

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

private

Inputs of the algorithm, represented as DataNode's.

Definition at line 232 of file PrecedenceRulesGraph.h.

bool concurrency::AlgorithmNode::m_inverted

private

Whether the selection result is negated or not.

Definition at line 216 of file PrecedenceRulesGraph.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 238 of file PrecedenceRulesGraph.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 230 of file PrecedenceRulesGraph.h.

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

private

XXX: CF tests.

Definition at line 220 of file PrecedenceRulesGraph.h.

float concurrency::AlgorithmNode::m_rank

private

Algorithm rank of any kind.

Definition at line 234 of file PrecedenceRulesGraph.h.

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

private

Representatives (including clones) of the node.

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

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

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation