#include <src/PrecedenceRulesGraph.h>

Inheritance diagram for concurrency::DecisionNode:

Collaboration diagram for concurrency::DecisionNode:

[legend]

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

	~DecisionNode () override
	Destructor. More...

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

bool	accept (IGraphVisitor &visitor) override

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

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

int	updateState (AlgsExecutionStates &states, std::vector< int > &node_decisions) const override
	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

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

Public Attributes
bool	m_modeConcurrent
	Whether all daughters will be evaluated concurrently or sequentially. More...

bool	m_modePromptDecision
	Whether to evaluate the hub decision ASA its child decisions allow to do that. More...

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

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

Public Attributes inherited from concurrency::ControlFlowNode
PrecedenceRulesGraph *	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 PrecedenceRulesGraph.h.

Constructor & Destructor Documentation

concurrency::DecisionNode::DecisionNode	(	PrecedenceRulesGraph &	graph,
		unsigned int	nodeIndex,
		const std::string &	name,
		bool	modeConcurrent,
		bool	modePromptDecision,
		bool	modeOR,
		bool	allPass
	)

inline

Constructor.

Definition at line 89 of file PrecedenceRulesGraph.h.

                                                                                                                                                                       :
       ControlFlowNode(graph, nodeIndex, name),
       m_modeConcurrent(modeConcurrent), m_modePromptDecision(modePromptDecision), m_modeOR(modeOR), m_allPass(allPass), m_children()
       {}

concurrency::DecisionNode::~DecisionNode ( )

override

Destructor.

Definition at line 22 of file PrecedenceRulesGraph.cpp.

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

Member Function Documentation

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

overridevirtual

Implements concurrency::ControlFlowNode.

Definition at line 192 of file PrecedenceRulesGraph.cpp.

   {
 
     if ( visitor.visitEnter( *this ) ) {
       // try to aggregate a decision
       bool result = visitor.visit( *this );
 
       // if a decision was made for this node, propagate the result upwards
       if ( result ) {
         for ( auto parent : m_parents ) {
           parent->accept( visitor );
         }
         return false;
       }
 
       // if no decision can be made yet, request further information downwards
       for ( auto child : m_children ) {
         bool result = child->accept( visitor );
         if (!m_modeConcurrent)
           if ( result ) break; //stop on first unresolved child if its decision hub is sequential
       }
 
       return true; // visitor was accepted to try to aggregate the node's decision
     }
 
     return false; // visitor was rejected (since the decision node has an aggregated decision already)
   }

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

Add a daughter node.

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

115 {return m_children;}

concurrency::DecisionNode::m_children

std::vector< ControlFlowNode * > m_children

All direct daughter nodes in the tree.

Definition: PrecedenceRulesGraph.h:133

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

overridevirtual

Initialize.

Implements concurrency::ControlFlowNode.

Definition at line 29 of file PrecedenceRulesGraph.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

overridevirtual

Print a string representing the control flow state.

Implements concurrency::ControlFlowNode.

Definition at line 50 of file PrecedenceRulesGraph.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

overridevirtual

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

Implements concurrency::ControlFlowNode.

Definition at line 170 of file PrecedenceRulesGraph.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_modePromptDecision ) return true;
       } else if ( m_modePromptDecision ) {
         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

overridevirtual

XXX: CF tests.

Implements concurrency::ControlFlowNode.

Definition at line 103 of file PrecedenceRulesGraph.cpp.

   {
 
     int decision           = ( ( m_allPass && m_modePromptDecision ) ? 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 prompt decision, 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_modePromptDecision && !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

overridevirtual

Method to set algos to CONTROLREADY, if possible.

Implements concurrency::ControlFlowNode.

Definition at line 63 of file PrecedenceRulesGraph.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_modePromptDecision ) ? 1 : -1 );
     bool hasUndecidedChild = false;
     for ( auto daughter : m_children ) {
       if ( m_modePromptDecision && ( -1 != decision || hasUndecidedChild ) ) {
         node_decisions[m_nodeIndex] = decision;
         return decision;
       } // if prompt decision, 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 130 of file PrecedenceRulesGraph.h.

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

private

All direct daughter nodes in the tree.

Definition at line 133 of file PrecedenceRulesGraph.h.

bool concurrency::DecisionNode::m_modeConcurrent

Whether all daughters will be evaluated concurrently or sequentially.

Definition at line 123 of file PrecedenceRulesGraph.h.

bool concurrency::DecisionNode::m_modeOR

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

Definition at line 128 of file PrecedenceRulesGraph.h.

bool concurrency::DecisionNode::m_modePromptDecision

Whether to evaluate the hub decision ASA its child decisions allow to do that.

Applicable to both concurrent and sequential cases.

Definition at line 126 of file PrecedenceRulesGraph.h.

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

private

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

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

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation