#include <src/ExecutionFlowGraph.h>

Inheritance diagram for concurrency::DecisionNode:

Collaboration diagram for concurrency::DecisionNode:

Public Member Functions
	DecisionNode (ExecutionFlowGraph &graph, unsigned int nodeIndex, const std::string &name, bool modeOR, bool allPass, bool isLazy)
	Constructor. More...

virtual	~DecisionNode ()
	Destructor. More...

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

virtual bool	accept (IGraphVisitor &visitor)

virtual bool	promoteToControlReadyState (const int &slotNum, AlgsExecutionStates &states, std::vector< int > &node_decisions) const
	XXX: CF tests. Method to set algos to CONTROLREADY, if possible. More...

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

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

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

void	addDaughterNode (ControlFlowNode *node)
	Add a daughter node. More...

const std::vector< ControlFlowNode * > &	getDaughters () const

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

Public Attributes
bool	m_modeOR
	Whether acting as "and" (false) or "or" node (true) More...

bool	m_allPass
	Whether always passing regardless of daughter results. More...

bool	m_isLazy
	Whether to evaluate lazily - i.e. whether to stop once result known. More...

Public Attributes inherited from concurrency::ControlFlowNode
ExecutionFlowGraph *	m_graph

Private Attributes
std::vector< ControlFlowNode * >	m_children
	All direct daughter nodes in the tree. More...

std::vector< DecisionNode * >	m_parents
	XXX: CF tests. All direct parent nodes in the tree. More...

Additional Inherited Members
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 86 of file ExecutionFlowGraph.h.

Constructor & Destructor Documentation

concurrency::DecisionNode::DecisionNode	(	ExecutionFlowGraph &	graph,
		unsigned int	nodeIndex,
		const std::string &	name,
		bool	modeOR,
		bool	allPass,
		bool	isLazy
	)

inline

Constructor.

Definition at line 89 of file ExecutionFlowGraph.h.

                                                                                                                                    :
       ControlFlowNode(graph, nodeIndex, name),
       m_modeOR(modeOR), m_allPass(allPass), m_isLazy(isLazy), m_children()
       {};

concurrency::DecisionNode::~DecisionNode ( )

virtual

Destructor.

Definition at line 15 of file ExecutionFlowGraph.cpp.

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

Member Function Documentation

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

virtual

Implements concurrency::ControlFlowNode.

Definition at line 177 of file ExecutionFlowGraph.cpp.

                                                   {
 
     if (visitor.visitEnter(*this)) {
       bool result = visitor.visit(*this);
       if (result)
         return visitor.visitLeave(*this);
 
       for (auto child : m_children) {
         bool keepGoing = child->accept(visitor);
         if (m_isLazy && !keepGoing)
           return false; //break;
       }
     }
 
     return true;
   }

void concurrency::DecisionNode::addDaughterNode ( ControlFlowNode * node )

Add a daughter node.

Definition at line 36 of file ExecutionFlowGraph.cpp.

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

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

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

Definition at line 29 of file ExecutionFlowGraph.cpp.

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

const std::vector<ControlFlowNode*>& concurrency::DecisionNode::getDaughters ( ) const

inline

Definition at line 115 of file ExecutionFlowGraph.h.

115 {return m_children;}

concurrency::DecisionNode::m_children

std::vector< ControlFlowNode * > m_children

All direct daughter nodes in the tree.

Definition: ExecutionFlowGraph.h:130

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

virtual

Initialize.

Implements concurrency::ControlFlowNode.

Definition at line 22 of file ExecutionFlowGraph.cpp.

                                                                                                  {
 
     for (auto daughter : m_children)
       daughter->initialize(algname_index_map);
   }

void concurrency::DecisionNode::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 43 of file ExecutionFlowGraph.cpp.

                                                                           {
 
     output << std::string(recursionLevel, ' ') << m_nodeName << " (" << m_nodeIndex << ")" << ", w/ decision: "
            << stateToString(node_decisions[m_nodeIndex]) << "(" << node_decisions[m_nodeIndex] <<")" << std::endl;
     for (auto daughter : m_children ) {
       daughter->printState(output,states,node_decisions,recursionLevel+2);
     }
   }

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

virtual

XXX: CF tests. Method to set algos to CONTROLREADY, if possible.

Implements concurrency::ControlFlowNode.

Definition at line 155 of file ExecutionFlowGraph.cpp.

                                                                                       {
     //std::cout << "REACHED DECISNODE " << m_nodeName << std::endl;
     if (-1 != node_decisions[m_nodeIndex]) {
       return true;
     }
 
     for (auto daughter : m_children ) {
       auto res = node_decisions[daughter->getNodeIndex()];
       if (-1 == res) {
         daughter->promoteToControlReadyState(slotNum, states, node_decisions);
         if (m_isLazy) return true;
       } else if (m_isLazy) {
         if ((false == m_modeOR && res == 0) || (true == m_modeOR && res == 1)) return true;
       }
     }
 
     return true;
   }

void concurrency::DecisionNode::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 85 of file ExecutionFlowGraph.cpp.

                                                                           {
 
     int decision = ((m_allPass && m_isLazy) ? 1 : -1);
     bool keepGoing = true;
     bool hasUndecidedChild = false;
     //std::cout << "++++++++++++++++++++BEGIN(UPDATING)++++++++++++++++++++" << std::endl;
     //std::cout << "UPDATING DAUGHTERS of DECISION NODE: " << m_nodeName << std::endl;
 
     for (auto daughter : m_children){
       // if lazy return once result is known already or we can't fully evaluate
       // right now because one daughter decision is missing still
       //std::cout << "----UPDATING DAUGHTER: " << daughter->getNodeName() << std::endl;
       if (m_isLazy && !keepGoing) {
         node_decisions[m_nodeIndex] = decision;
         //std::cout << "STOPPING ITERATION OVER (UPDATING) DECISION NODE CHILDREN: " << m_nodeName << std::endl;
         break;
         //return;
       }
 
       // modified
       int& res = node_decisions[daughter->getNodeIndex()];
       if (-1 == res) {
         hasUndecidedChild = true;
         if (typeid(*daughter) != typeid(concurrency::DecisionNode)) {
           auto algod = (AlgorithmNode*) daughter;
           algod->promoteToControlReadyState(slotNum,states,node_decisions);
           bool result = algod->promoteToDataReadyState(slotNum, requestor);
           if (result)
             keepGoing = false;
         } else {
           daughter->updateDecision(slotNum, states, node_decisions, requestor);
         }
 
       // "and"-mode (once first result false, the overall decision is false)
       } else if (false == m_modeOR && res == 0) {
         decision = 0;
         keepGoing = false;
       // "or"-mode  (once first result true, the overall decision is true)
       } else if (true  == m_modeOR && res == 1) {
         decision = 1;
         keepGoing = false;
       }
     }
 
     // what to do with yet undefined answers depends on whether AND or OR mode applies
     if (!hasUndecidedChild &&  -1 == decision ) {
       // OR mode: all results known, and none true -> reject
       if ( true == m_modeOR) {
         decision = 0;
       // AND mode: all results known, and no false -> accept
       } else {
         decision = 1;
       }
     }
 
     // in all other cases I stay with previous decisions
     node_decisions[m_nodeIndex] = decision;
 
     // propagate decision upwards through the decision graph
     if (-1 != decision)
       for (auto p : m_parents)
           p->updateDecision(slotNum, states, node_decisions, requestor);
 
     //std::cout << "++++++++++++++++++++END(UPDATING)++++++++++++++++++++" << std::endl;
   }

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

virtual

Method to set algos to CONTROLREADY, if possible.

Implements concurrency::ControlFlowNode.

Definition at line 56 of file ExecutionFlowGraph.cpp.

                                                                       {
     // check whether we already had a result earlier
     //    if (-1 != node_decisions[m_nodeIndex] ) { return node_decisions[m_nodeIndex]; }
     int decision = ((m_allPass && m_isLazy) ? 1 : -1);
     bool hasUndecidedChild = false;
     for (auto daughter : m_children){
       if (m_isLazy && (-1 !=decision || hasUndecidedChild ) ) {
         node_decisions[m_nodeIndex] = decision;
         return decision;} // if lazy return once result is known already or we can't fully evaluate right now because one daugther decision is missing still
       auto res = daughter->updateState(states, node_decisions);
       if ( -1 == res) {hasUndecidedChild = true;}
       else if ( false == m_modeOR && res == 0 ){decision = 0;} // "and"-mode (once first result false, the overall decision is false)
       else if ( true  == m_modeOR && res == 1){decision = 1;} // "or"-mode  (once first result true, the overall decision is true)
     }
     // what to do with yet undefined answers depends on whether AND or OR mode applies
     if (!hasUndecidedChild &&  -1 == decision ) {
       // OR mode: all results known, and none true -> reject
       if ( true == m_modeOR){ decision = 0; }
       // AND mode: all results known, and no false -> accept
       else { decision = 1; }
     }
     // in all other cases I stay with previous decisions
     node_decisions[m_nodeIndex] = decision;
     if (m_allPass) decision = 1;
     return decision;
   }

Member Data Documentation

bool concurrency::DecisionNode::m_allPass

Whether always passing regardless of daughter results.

Definition at line 125 of file ExecutionFlowGraph.h.

std::vector<ControlFlowNode*> concurrency::DecisionNode::m_children

private

All direct daughter nodes in the tree.

Definition at line 130 of file ExecutionFlowGraph.h.

bool concurrency::DecisionNode::m_isLazy

Whether to evaluate lazily - i.e. whether to stop once result known.

Definition at line 127 of file ExecutionFlowGraph.h.

bool concurrency::DecisionNode::m_modeOR

Whether acting as "and" (false) or "or" node (true)

Definition at line 123 of file ExecutionFlowGraph.h.

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

private

XXX: CF tests. All direct parent nodes in the tree.

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

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation