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

const std::vector< DecisionNode * > &	getParentDecisionHubs () const
	Get all parent decision hubs. 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	isOptimist () const
	Check if positive control flow decision is enforced. More...

bool	isLiar () const
	Check if control flow logic is always inverted. More...

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

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

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

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

Definition at line 416 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 409 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 402 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:229

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

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;
   }

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

inline

XXX: CF tests.

Definition at line 185 of file PrecedenceRulesGraph.h.

185 { return m_algoIndex; }

concurrency::AlgorithmNode::m_algoIndex

unsigned int m_algoIndex

The index of the algorithm.

Definition: PrecedenceRulesGraph.h:217

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

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

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

inline

Get all consumer nodes.

Definition at line 178 of file PrecedenceRulesGraph.h.

178 {return m_inputs;}

concurrency::AlgorithmNode::m_inputs

std::vector< DataNode * > m_inputs

Inputs of the algorithm, represented as DataNode's.

Definition: PrecedenceRulesGraph.h:237

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

inline

Get all supplier nodes.

Definition at line 176 of file PrecedenceRulesGraph.h.

176 {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:235

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

inline

Get all parent decision hubs.

Definition at line 169 of file PrecedenceRulesGraph.h.

169 {return m_parents;}

concurrency::AlgorithmNode::m_parents

std::vector< DecisionNode * > m_parents

XXX: CF tests.

Definition: PrecedenceRulesGraph.h:225

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

inline

Get Algorithm rank.

Definition at line 182 of file PrecedenceRulesGraph.h.

182 {return m_rank;}

concurrency::AlgorithmNode::m_rank

float m_rank

Algorithm rank of any kind.

Definition: PrecedenceRulesGraph.h:239

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

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

189 {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:243

bool concurrency::AlgorithmNode::isLiar ( ) const

inline

Check if control flow logic is always inverted.

Definition at line 193 of file PrecedenceRulesGraph.h.

193 {return m_inverted;};

concurrency::AlgorithmNode::m_inverted

bool m_inverted

Whether the selection result is negated or not.

Definition: PrecedenceRulesGraph.h:221

bool concurrency::AlgorithmNode::isOptimist ( ) const

inline

Check if positive control flow decision is enforced.

Definition at line 191 of file PrecedenceRulesGraph.h.

191 {return m_allPass;};

concurrency::AlgorithmNode::m_allPass

bool m_allPass

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

Definition: PrecedenceRulesGraph.h:223

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 315 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 187 of file PrecedenceRulesGraph.h.

187 { 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:243

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

inline

Set Algorithm rank.

Definition at line 180 of file PrecedenceRulesGraph.h.

180 {m_rank = rank;}

concurrency::AlgorithmNode::m_rank

float m_rank

Algorithm rank of any kind.

Definition: PrecedenceRulesGraph.h:239

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 351 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 ) {
       auto& slot = (*m_graph->m_eventSlots)[slotNum];
       auto promoter = DataReadyPromoter(slot);
       for ( auto output : m_outputs )
         for ( auto consumer : output->getConsumers() )
           if (State::CONTROLREADY == states[consumer->getAlgoIndex()])
             consumer->accept(promoter);
 
       auto vis = concurrency::Supervisor(slot);
       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 325 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 217 of file PrecedenceRulesGraph.h.

std::string concurrency::AlgorithmNode::m_algoName

private

The name of the algorithm.

Definition at line 219 of file PrecedenceRulesGraph.h.

bool concurrency::AlgorithmNode::m_allPass

private

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

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

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

private

Inputs of the algorithm, represented as DataNode's.

Definition at line 237 of file PrecedenceRulesGraph.h.

bool concurrency::AlgorithmNode::m_inverted

private

Whether the selection result is negated or not.

Definition at line 221 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 243 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 235 of file PrecedenceRulesGraph.h.

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

private

XXX: CF tests.

Definition at line 225 of file PrecedenceRulesGraph.h.

float concurrency::AlgorithmNode::m_rank

private

Algorithm rank of any kind.

Definition at line 239 of file PrecedenceRulesGraph.h.

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

private

Representatives (including clones) of the node.

Definition at line 241 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 229 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