| The Gaudi Framework v29r0 (ff2e7097)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

PrecedenceRulesGraph.h
Go to the documentation of this file.
1 #ifndef GAUDIHIVE_PRECEDENCERULESGRAPH_H
2 #define GAUDIHIVE_PRECEDENCERULESGRAPH_H
3
4 // std includes
5 #include <algorithm>
6 #include <chrono>
7 #include <sstream>
8 #include <unordered_map>
9 #include <vector>
10
11 #include <boost/filesystem.hpp>
12 #include <boost/graph/adjacency_list.hpp>
13 #include <boost/graph/graphml.hpp>
14 #include <boost/variant.hpp>
15
16 // fwk includes
17 #include "AlgsExecutionStates.h"
18 #include "EventSlot.h"
19 #include "GaudiKernel/Algorithm.h"
20 #include "GaudiKernel/CommonMessaging.h"
21 #include "GaudiKernel/ICondSvc.h"
22 #include "GaudiKernel/ITimelineSvc.h"
23 #include "IGraphVisitor.h"
24
25 namespace precedence
26 {
27 using boost::static_visitor;
28
29 // Precedence trace utilities ==============================================
30 struct AlgoTraceProps {
31 AlgoTraceProps() {}
32 AlgoTraceProps( const std::string& name, int index, int rank, double runtime )
33 : m_name( name ), m_index( index ), m_rank( rank ), m_runtime( runtime )
34 {
35 }
36 std::string m_name;
37 int m_index{-1};
38 int m_rank{-1};
39 int m_runtime{-1}; // ns
40 int m_eccentricity{-1};
41 };
42
43 using PrecTrace = boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS, AlgoTraceProps>;
44 using AlgoTraceVertex = boost::graph_traits<PrecTrace>::vertex_descriptor;
45
46 // Precedence rules utilities ==============================================
47 struct AlgoProps {
48 AlgoProps() {}
49 AlgoProps( Algorithm* algo, uint nodeIndex, uint algoIndex, bool inverted, bool allPass )
50 : m_name( algo->name() )
51 , m_nodeIndex( nodeIndex )
52 , m_algoIndex( algoIndex )
53 , m_algorithm( algo )
54 , m_inverted( inverted )
55 , m_allPass( allPass )
56 , m_isIOBound( algo->isIOBound() )
57 {
58 }
59
60 std::string m_name{""};
61 int m_nodeIndex{-1};
62 int m_algoIndex{-1};
63 int m_rank{-1};
65 Algorithm* m_algorithm{nullptr};
66
68 bool m_inverted{false};
70 bool m_allPass{false};
72 bool m_isIOBound{false};
73 };
74
75 struct DecisionHubProps {
76 DecisionHubProps( const std::string& name, uint nodeIndex, bool modeConcurrent, bool modePromptDecision,
77 bool modeOR, bool allPass )
78 : m_name( name )
79 , m_nodeIndex( nodeIndex )
80 , m_modeConcurrent( modeConcurrent )
81 , m_modePromptDecision( modePromptDecision )
82 , m_modeOR( modeOR )
83 , m_allPass( allPass )
84 {
85 }
86
87 std::string m_name;
88 uint m_nodeIndex;
89
91 bool m_modeConcurrent;
94 bool m_modePromptDecision;
96 bool m_modeOR;
98 bool m_allPass;
99 };
100
101 struct DataProps {
102 DataProps( const DataObjID& id ) : m_id( id ) {}
103
104 DataObjID m_id;
105 };
106
107 // Vertex unpacking ========================================================
108
109 struct VertexName : static_visitor<std::string> {
110 std::string operator()( const AlgoProps& props ) const { return props.m_name; }
111
112 std::string operator()( const DecisionHubProps& props ) const { return props.m_name; }
113
114 std::string operator()( const DataProps& props ) const { return props.m_id.fullKey(); }
115 };
116
117 struct GroupMode : static_visitor<std::string> {
118 std::string operator()( const AlgoProps& ) const { return ""; }
119
120 std::string operator()( const DecisionHubProps& props ) const
121 {
122 return props.m_modeConcurrent ? "Concurrent" : "Sequential";
123 }
124
125 std::string operator()( const DataProps& ) const { return ""; }
126 };
127
128 struct GroupLogic : static_visitor<std::string> {
129 std::string operator()( const AlgoProps& ) const { return ""; }
130
131 std::string operator()( const DecisionHubProps& props ) const { return props.m_modeOR ? "OR" : "AND"; }
132
133 std::string operator()( const DataProps& ) const { return ""; }
134 };
135
136 struct GroupExit : static_visitor<std::string> {
137 std::string operator()( const AlgoProps& ) const { return ""; }
138
139 std::string operator()( const DecisionHubProps& props ) const
140 {
141 return props.m_modePromptDecision ? "Early" : "Late";
142 }
143
144 std::string operator()( const DataProps& ) const { return ""; }
145 };
146
147 struct DecisionNegation : static_visitor<std::string> {
148 std::string operator()( const AlgoProps& props ) const { return props.m_inverted ? "Inverted" : "Non-inverted"; }
149
150 std::string operator()( const DecisionHubProps& ) const { return ""; }
151
152 std::string operator()( const DataProps& ) const { return ""; }
153 };
154
155 struct AllPass : static_visitor<std::string> {
156 std::string operator()( const AlgoProps& props ) const { return props.m_allPass ? "Optimist" : "Realist"; }
157
158 std::string operator()( const DecisionHubProps& props ) const { return props.m_allPass ? "Optimist" : "Realist"; }
159
160 std::string operator()( const DataProps& ) const { return ""; }
161 };
162
163 struct CFDecision : static_visitor<std::string> {
164 CFDecision( const EventSlot& slot ) : m_slot( slot ) {}
165
166 std::string operator()( const AlgoProps& props ) const
167 {
168 return std::to_string( m_slot.controlFlowState.at( props.m_nodeIndex ) );
169 }
170
171 std::string operator()( const DecisionHubProps& props ) const
172 {
173 return std::to_string( m_slot.controlFlowState.at( props.m_nodeIndex ) );
174 }
175
176 std::string operator()( const DataProps& ) const { return ""; }
177
178 EventSlot m_slot;
179 };
180
181 struct FSMState : static_visitor<std::string> {
182 FSMState( const EventSlot& slot ) : m_slot( slot ) {}
183
184 std::string operator()( const AlgoProps& props ) const
185 {
186 using State = AlgsExecutionStates::State;
187 State state = m_slot.algsStates[props.m_algoIndex];
188 switch ( state ) {
189 case State::INITIAL:
190 return "INITIAL";
191 case State::CONTROLREADY:
192 return "CONTROLREADY";
193 case State::DATAREADY:
194 return "DATAREADY";
195 case State::EVTACCEPTED:
196 return "EVTACCEPTED";
197 case State::EVTREJECTED:
198 return "EVTREJECTED";
199 case State::ERROR:
200 return "ERROR";
201 default:
202 return "UKNOWN";
203 }
204 }
205
206 std::string operator()( const DecisionHubProps& ) const { return ""; }
207
208 std::string operator()( const DataProps& ) const { return ""; }
209
210 EventSlot m_slot;
211 };
212
213 struct StartTime : static_visitor<std::string> {
214 StartTime( SmartIF<ITimelineSvc> timelineSvc ) : m_timelineSvc( timelineSvc ) {}
215
216 std::string operator()( const AlgoProps& props ) const
217 {
218
219 std::string startTime = "UKNOWN";
220
221 if ( m_timelineSvc.isValid() ) {
222
223 TimelineEvent te{};
224 te.algorithm = props.m_name;
225 m_timelineSvc->getTimelineEvent( te );
226 startTime = std::to_string(
227 std::chrono::duration_cast<std::chrono::nanoseconds>( te.start.time_since_epoch() ).count() );
228 }
229
230 return startTime;
231 }
232
233 std::string operator()( const DecisionHubProps& ) const { return ""; }
234
235 std::string operator()( const DataProps& ) const { return ""; }
236
237 SmartIF<ITimelineSvc> m_timelineSvc;
238 };
239
240 struct EndTime : static_visitor<std::string> {
241 EndTime( SmartIF<ITimelineSvc> timelineSvc ) : m_timelineSvc( timelineSvc ) {}
242
243 std::string operator()( const AlgoProps& props ) const
244 {
245
246 std::string endTime = "UKNOWN";
247
248 if ( m_timelineSvc.isValid() ) {
249
250 TimelineEvent te{};
251 te.algorithm = props.m_name;
252 m_timelineSvc->getTimelineEvent( te );
253 endTime =
254 std::to_string( std::chrono::duration_cast<std::chrono::nanoseconds>( te.end.time_since_epoch() ).count() );
255 }
256
257 return endTime;
258 }
259
260 std::string operator()( const DecisionHubProps& ) const { return ""; }
261
262 std::string operator()( const DataProps& ) const { return ""; }
263
264 SmartIF<ITimelineSvc> m_timelineSvc;
265 };
266
267 struct Duration : static_visitor<std::string> {
268 Duration( SmartIF<ITimelineSvc> timelineSvc ) : m_timelineSvc( timelineSvc ) {}
269
270 std::string operator()( const AlgoProps& props ) const
271 {
272
273 std::string time = "UKNOWN";
274
275 if ( m_timelineSvc.isValid() ) {
276
277 TimelineEvent te;
278 te.algorithm = props.m_name;
279 m_timelineSvc->getTimelineEvent( te );
280 time = std::to_string( std::chrono::duration_cast<std::chrono::nanoseconds>( te.end - te.start ).count() );
281 }
282
283 return time;
284 }
285
286 std::string operator()( const DecisionHubProps& ) const { return ""; }
287
288 std::string operator()( const DataProps& ) const { return ""; }
289
290 SmartIF<ITimelineSvc> m_timelineSvc;
291 };
292
293 struct Operations : static_visitor<std::string> {
294 std::string operator()( const AlgoProps& props ) const { return props.m_isIOBound ? "IO-bound" : "CPU-bound"; }
295
296 std::string operator()( const DecisionHubProps& ) const { return ""; }
297
298 std::string operator()( const DataProps& ) const { return ""; }
299 };
300
301 static inline std::ostream& operator<<( std::ostream& os, const AlgoProps& ) { return os << "Algo"; }
302 static inline std::ostream& operator<<( std::ostream& os, const DecisionHubProps& ) { return os << "DecisionHub"; }
303 static inline std::ostream& operator<<( std::ostream& os, const DataProps& ) { return os << "Data"; }
304
305 //=========================================================================
306
307 using VariantVertexProps = boost::variant<AlgoProps, DecisionHubProps, DataProps>;
308 using PRGraph = boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS, VariantVertexProps>;
309 using PRVertexDesc = boost::graph_traits<PRGraph>::vertex_descriptor;
310
311 } // namespace prules
312
313 struct Cause {
314 enum class source { Root, Task };
315
316 source m_source;
317 std::string m_sourceName;
318 };
319
320 namespace concurrency
321 {
322
323 using State = AlgsExecutionStates::State;
324 class PrecedenceRulesGraph;
325
326 using precedence::PRVertexDesc;
327 using precedence::AlgoProps;
328 using precedence::DecisionHubProps;
329 using precedence::DataProps;
330 using precedence::VariantVertexProps;
331
332 // ==========================================================================
333 class ControlFlowNode
334 {
335 public:
337 ControlFlowNode( PrecedenceRulesGraph& graph, unsigned int nodeIndex, const std::string& name )
338 : m_graph( &graph ), m_nodeIndex( nodeIndex ), m_nodeName( name )
339 {
340 }
342 virtual ~ControlFlowNode() {}
343
345 virtual bool accept( IGraphVisitor& visitor ) = 0;
347 virtual void printState( std::stringstream& output, AlgsExecutionStates& states,
348 const std::vector<int>& node_decisions, const unsigned int& recursionLevel ) const = 0;
350 const unsigned int& getNodeIndex() const { return m_nodeIndex; }
352 const std::string& getNodeName() const { return m_nodeName; }
353
354 public:
355 PrecedenceRulesGraph* m_graph;
356
357 protected:
359 std::string stateToString( const int& stateId ) const;
360 unsigned int m_nodeIndex;
361 std::string m_nodeName;
362 };
363
364 class DecisionNode : public ControlFlowNode
365 {
366 public:
368 DecisionNode( PrecedenceRulesGraph& graph, unsigned int nodeIndex, const std::string& name, bool modeConcurrent,
369 bool modePromptDecision, bool modeOR, bool allPass )
370 : ControlFlowNode( graph, nodeIndex, name )
371 , m_modeConcurrent( modeConcurrent )
372 , m_modePromptDecision( modePromptDecision )
373 , m_modeOR( modeOR )
374 , m_allPass( allPass )
375 , m_children()
376 {
377 }
378
380 ~DecisionNode() override;
381
383 bool accept( IGraphVisitor& visitor ) override;
385 void addParentNode( DecisionNode* node );
387 void addDaughterNode( ControlFlowNode* node );
389 const std::vector<ControlFlowNode*>& getDaughters() const { return m_children; }
391 void printState( std::stringstream& output, AlgsExecutionStates& states, const std::vector<int>& node_decisions,
392 const unsigned int& recursionLevel ) const override;
393
394 public:
396 bool m_modeConcurrent;
399 bool m_modePromptDecision;
401 bool m_modeOR;
403 bool m_allPass;
405 std::vector<ControlFlowNode*> m_children;
407 std::vector<DecisionNode*> m_parents;
408 };
409
410 // ==========================================================================
411 class DataNode;
412
413 class AlgorithmNode : public ControlFlowNode
414 {
415 public:
417 AlgorithmNode( PrecedenceRulesGraph& graph, Algorithm* algoPtr, unsigned int nodeIndex, unsigned int algoIndex,
418 bool inverted, bool allPass )
419 : ControlFlowNode( graph, nodeIndex, algoPtr->name() )
420 , m_algorithm( algoPtr )
421 , m_algoIndex( algoIndex )
422 , m_algoName( algoPtr->name() )
423 , m_inverted( inverted )
424 , m_allPass( allPass )
425 , m_rank( -1 )
426 , m_isIOBound( algoPtr->isIOBound() ){};
428 ~AlgorithmNode();
429
431 bool accept( IGraphVisitor& visitor ) override;
432
434 void addParentNode( DecisionNode* node );
436 const std::vector<DecisionNode*>& getParentDecisionHubs() const { return m_parents; }
437
439 void addOutputDataNode( DataNode* node );
441 void addInputDataNode( DataNode* node );
443 const std::vector<DataNode*>& getOutputDataNodes() const { return m_outputs; }
445 const std::vector<DataNode*>& getInputDataNodes() const { return m_inputs; }
446
448 void setRank( float& rank ) { m_rank = rank; }
450 const float& getRank() const { return m_rank; }
451
453 Algorithm* getAlgorithm() const { return m_algorithm; }
455 const unsigned int& getAlgoIndex() const { return m_algoIndex; }
456
458 void setIOBound( bool value ) { m_isIOBound = value; }
460 bool isIOBound() const { return m_isIOBound; }
461
463 bool isOptimist() const { return m_allPass; };
465 bool isLiar() const { return m_inverted; };
466
468 void printState( std::stringstream& output, AlgsExecutionStates& states, const std::vector<int>& node_decisions,
469 const unsigned int& recursionLevel ) const override;
470
471 public:
473 std::vector<DecisionNode*> m_parents;
474
475 private:
477 Algorithm* m_algorithm;
479 unsigned int m_algoIndex;
481 std::string m_algoName;
483 bool m_inverted;
485 bool m_allPass;
487 float m_rank;
489 bool m_isIOBound;
490
492 std::vector<DataNode*> m_outputs;
494 std::vector<DataNode*> m_inputs;
495 };
496
497 // ==========================================================================
498 class DataNode
499 {
500 public:
502 DataNode( PrecedenceRulesGraph& graph, const DataObjID& path ) : m_graph( &graph ), m_data_object_path( path ) {}
503
504 const DataObjID& getPath() { return m_data_object_path; }
505
507 bool accept( IGraphVisitor& visitor )
508 {
509 if ( visitor.visitEnter( *this ) ) return visitor.visit( *this );
510 return true;
511 }
513 void addProducerNode( AlgorithmNode* node )
514 {
515 if ( std::find( m_producers.begin(), m_producers.end(), node ) == m_producers.end() )
516 m_producers.push_back( node );
517 }
519 void addConsumerNode( AlgorithmNode* node )
520 {
521 if ( std::find( m_consumers.begin(), m_consumers.end(), node ) == m_consumers.end() )
522 m_consumers.push_back( node );
523 }
525 const std::vector<AlgorithmNode*>& getProducers() const { return m_producers; }
527 const std::vector<AlgorithmNode*>& getConsumers() const { return m_consumers; }
528
529 public:
530 PrecedenceRulesGraph* m_graph;
531
532 private:
533 DataObjID m_data_object_path;
534 std::vector<AlgorithmNode*> m_producers;
535 std::vector<AlgorithmNode*> m_consumers;
536 };
537
538 class ConditionNode : public DataNode
539 {
540 public:
542 ConditionNode( PrecedenceRulesGraph& graph, const DataObjID& path, SmartIF<ICondSvc> condSvc )
543 : DataNode( graph, path ), m_condSvc( condSvc )
544 {
545 }
546
550 bool accept( IGraphVisitor& visitor )
551 {
552 if ( visitor.visitEnter( *this ) ) return visitor.visit( *this );
553 return true;
554 }
555
556 public:
557 // Service for Conditions handling
558 SmartIF<ICondSvc> m_condSvc;
559 };
560
561 // ==========================================================================
562 using AlgoNodesMap = std::unordered_map<std::string, AlgorithmNode*>;
563 using DecisionHubsMap = std::unordered_map<std::string, DecisionNode*>;
564 using DataNodesMap = std::unordered_map<DataObjID, DataNode*, DataObjID_Hasher>;
565
566 using AlgoInputsMap = std::unordered_map<std::string, DataObjIDColl>;
567 using AlgoOutputsMap = std::unordered_map<std::string, DataObjIDColl>;
568
569 struct IPrecedenceRulesGraph {
570 virtual ~IPrecedenceRulesGraph() = default;
571 };
572
573 class PrecedenceRulesGraph : public CommonMessaging<IPrecedenceRulesGraph>
574 {
575 public:
577 PrecedenceRulesGraph( const std::string& name, SmartIF<ISvcLocator> svc )
578 : m_headNode( 0 )
579 , m_nodeCounter( 0 )
580 , m_algoCounter( 0 )
581 , m_svcLocator( svc )
582 , m_name( name )
583 , m_initTime( std::chrono::system_clock::now() )
584 {
585 }
587 ~PrecedenceRulesGraph() override
588 {
589 if ( m_headNode != 0 ) delete m_headNode;
590 }
591
593 StatusCode initialize();
594
596 void accept( const std::string& algo_name, IGraphVisitor& visitor ) const;
597
599 StatusCode addDataNode( const DataObjID& dataPath );
601 DataNode* getDataNode( const DataObjID& dataPath ) const;
603 void registerIODataObjects( const Algorithm* algo );
605 StatusCode buildDataDependenciesRealm();
606
608 void addHeadNode( const std::string& headName, bool modeConcurrent, bool modePromptDecision, bool modeOR,
609 bool allPass );
611 DecisionNode* getHeadNode() const { return m_headNode; };
613 StatusCode addAlgorithmNode( Algorithm* daughterAlgo, const std::string& parentName, bool inverted, bool allPass );
615 AlgorithmNode* getAlgorithmNode( const std::string& algoName ) const;
617 StatusCode addDecisionHubNode( Algorithm* daughterAlgo, const std::string& parentName, bool modeConcurrent,
618 bool modePromptDecision, bool modeOR, bool allPass );
620 unsigned int getControlFlowNodeCounter() const { return m_nodeCounter; }
621
623 void rankAlgorithms( IGraphVisitor& ranker ) const;
624
626 const std::string& name() const override { return m_name; }
628 SmartIF<ISvcLocator>& serviceLocator() const override { return m_svcLocator; }
630 const std::chrono::system_clock::time_point getInitTime() const { return m_initTime; }
631
633 void printState( std::stringstream& output, AlgsExecutionStates& states, const std::vector<int>& node_decisions,
634 const unsigned int& recursionLevel ) const
635 {
636 m_headNode->printState( output, states, node_decisions, recursionLevel );
637 }
638
640 PRVertexDesc node( const std::string& ) const;
641
643 std::string dumpDataFlow() const;
645 std::string dumpControlFlow() const;
647 void dumpPrecRules( const boost::filesystem::path&, const EventSlot& slot );
649 void dumpPrecTrace( const boost::filesystem::path& );
651 void addEdgeToPrecTrace( const AlgorithmNode* u, const AlgorithmNode* v );
653 void dumpControlFlow( std::ostringstream&, ControlFlowNode*, const int& ) const;
654
655 private:
657 DecisionNode* m_headNode;
659 AlgoNodesMap m_algoNameToAlgoNodeMap;
661 DecisionHubsMap m_decisionNameToDecisionHubMap;
663 DataNodesMap m_dataPathToDataNodeMap;
665 AlgoInputsMap m_algoNameToAlgoInputsMap;
666 AlgoOutputsMap m_algoNameToAlgoOutputsMap;
667
669 unsigned int m_nodeCounter;
671 unsigned int m_algoCounter;
672
674 mutable SmartIF<ISvcLocator> m_svcLocator;
675 const std::string m_name;
676
677 const std::chrono::system_clock::time_point m_initTime;
678
680 precedence::PrecTrace m_precTrace;
681 std::map<std::string, precedence::AlgoTraceVertex> m_prec_trace_map;
683 precedence::PRGraph m_PRGraph;
684
686 bool m_conditionsRealmEnabled{false};
687 };
688
689 } // namespace concurrency
690 #endif
concurrency::AlgorithmNode::m_outputs
std::vector< DataNode * > m_outputs
Algorithm outputs (DataNodes)
Definition: PrecedenceRulesGraph.h:492
precedence::PRGraph
boost::adjacency_list< boost::vecS, boost::vecS, boost::bidirectionalS, VariantVertexProps > PRGraph
Definition: PrecedenceRulesGraph.h:308
precedence::GroupLogic::operator()
std::string operator()(const DecisionHubProps &props) const
Definition: PrecedenceRulesGraph.h:131
Algorithm.h
concurrency::AlgorithmNode::getAlgoIndex
const unsigned int & getAlgoIndex() const
Get algorithm index.
Definition: PrecedenceRulesGraph.h:455
precedence::CFDecision
Definition: PrecedenceRulesGraph.h:163
SmartIF< ITimelineSvc >
precedence::GroupMode
Definition: PrecedenceRulesGraph.h:117
Cause::source
source
Definition: PrecedenceRulesGraph.h:314
precedence::DecisionNegation::operator()
std::string operator()(const DecisionHubProps &) const
Definition: PrecedenceRulesGraph.h:150
concurrency::DecisionNode::m_parents
std::vector< DecisionNode * > m_parents
Direct parent nodes.
Definition: PrecedenceRulesGraph.h:407
precedence::AlgoTraceProps::AlgoTraceProps
AlgoTraceProps(const std::string &name, int index, int rank, double runtime)
Definition: PrecedenceRulesGraph.h:32
concurrency::DecisionNode
Definition: PrecedenceRulesGraph.h:364
concurrency::ControlFlowNode::ControlFlowNode
ControlFlowNode(PrecedenceRulesGraph &graph, unsigned int nodeIndex, const std::string &name)
Constructor.
Definition: PrecedenceRulesGraph.h:337
precedence::Duration
Definition: PrecedenceRulesGraph.h:267
precedence::AllPass::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:156
concurrency::AlgorithmNode::m_algoIndex
unsigned int m_algoIndex
The index of the algorithm.
Definition: PrecedenceRulesGraph.h:479
precedence
Definition: PrecedenceRulesGraph.h:25
concurrency::PrecedenceRulesGraph::getInitTime
const std::chrono::system_clock::time_point getInitTime() const
Definition: PrecedenceRulesGraph.h:630
precedence::StartTime::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:216
concurrency::DecisionNode::DecisionNode
DecisionNode(PrecedenceRulesGraph &graph, unsigned int nodeIndex, const std::string &name, bool modeConcurrent, bool modePromptDecision, bool modeOR, bool allPass)
Constructor.
Definition: PrecedenceRulesGraph.h:368
precedence::AlgoProps::AlgoProps
AlgoProps(Algorithm *algo, uint nodeIndex, uint algoIndex, bool inverted, bool allPass)
Definition: PrecedenceRulesGraph.h:49
concurrency::PrecedenceRulesGraph::m_precTrace
precedence::PrecTrace m_precTrace
facilities for algorithm precedence tracing
Definition: PrecedenceRulesGraph.h:680
GaudiPython.HistoUtils.path
path
Definition: HistoUtils.py:895
concurrency::AlgorithmNode::setIOBound
void setIOBound(bool value)
Set the I/O-boundness flag.
Definition: PrecedenceRulesGraph.h:458
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:32
precedence::AlgoTraceVertex
boost::graph_traits< PrecTrace >::vertex_descriptor AlgoTraceVertex
Definition: PrecedenceRulesGraph.h:44
compareRootHistos.state
state
Definition: compareRootHistos.py:422
DataObjID
Definition: DataObjID.h:37
concurrency::DataNode
Definition: PrecedenceRulesGraph.h:498
precedence::PRVertexDesc
boost::graph_traits< PRGraph >::vertex_descriptor PRVertexDesc
Definition: PrecedenceRulesGraph.h:309
precedence::AlgoTraceProps::m_eccentricity
int m_eccentricity
Definition: PrecedenceRulesGraph.h:40
concurrency::PrecedenceRulesGraph::m_initTime
const std::chrono::system_clock::time_point m_initTime
Definition: PrecedenceRulesGraph.h:677
concurrency::AlgorithmNode::m_algoName
std::string m_algoName
The name of the algorithm.
Definition: PrecedenceRulesGraph.h:481
concurrency::AlgorithmNode::getInputDataNodes
const std::vector< DataNode * > & getInputDataNodes() const
Get all consumer nodes.
Definition: PrecedenceRulesGraph.h:445
precedence::CFDecision::m_slot
EventSlot m_slot
Definition: PrecedenceRulesGraph.h:178
gaudirun.output
output
Definition: gaudirun.py:404
concurrency::AlgorithmNode::isOptimist
bool isOptimist() const
Check if positive control flow decision is enforced.
Definition: PrecedenceRulesGraph.h:463
concurrency
Definition: ControlFlowGraph.cpp:4
concurrency::PrecedenceRulesGraph::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: PrecedenceRulesGraph.h:628
concurrency::PrecedenceRulesGraph::m_algoNameToAlgoNodeMap
AlgoNodesMap m_algoNameToAlgoNodeMap
Index: map of algorithm&#39;s name to AlgorithmNode.
Definition: PrecedenceRulesGraph.h:659
concurrency::IGraphVisitor::visit
virtual bool visit(DecisionNode &)
Definition: IGraphVisitor.h:18
concurrency::ConditionNode::accept
bool accept(IGraphVisitor &visitor)
Need to hide the (identical) base method with this one so that visitEnter(ConditionNode&) and visit(C...
Definition: PrecedenceRulesGraph.h:550
precedence::FSMState
Definition: PrecedenceRulesGraph.h:181
concurrency::AlgorithmNode::setRank
void setRank(float &rank)
Set Algorithm rank.
Definition: PrecedenceRulesGraph.h:448
concurrency::DecisionNode::m_children
std::vector< ControlFlowNode * > m_children
All direct daughter nodes in the tree.
Definition: PrecedenceRulesGraph.h:405
precedence::AlgoProps
Definition: PrecedenceRulesGraph.h:47
precedence::GroupExit::operator()
std::string operator()(const AlgoProps &) const
Definition: PrecedenceRulesGraph.h:137
std::to_string
T to_string(T...args)
precedence::VertexName::operator()
std::string operator()(const DecisionHubProps &props) const
Definition: PrecedenceRulesGraph.h:112
precedence::DataProps::DataProps
DataProps(const DataObjID &id)
Definition: PrecedenceRulesGraph.h:102
plotSpeedupsPyRoot.time
time
Definition: plotSpeedupsPyRoot.py:154
concurrency::PrecedenceRulesGraph::printState
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.
Definition: PrecedenceRulesGraph.h:633
concurrency::PrecedenceRulesGraph::m_prec_trace_map
std::map< std::string, precedence::AlgoTraceVertex > m_prec_trace_map
Definition: PrecedenceRulesGraph.h:681
concurrency::AlgorithmNode::m_parents
std::vector< DecisionNode * > m_parents
Control flow parents of an AlgorithmNode (DecisionNodes)
Definition: PrecedenceRulesGraph.h:473
concurrency::ControlFlowNode
Definition: PrecedenceRulesGraph.h:333
precedence::AlgoProps::m_isIOBound
bool m_isIOBound
If an algorithm is blocking.
Definition: PrecedenceRulesGraph.h:72
std
STL namespace.
precedence::EndTime::m_timelineSvc
SmartIF< ITimelineSvc > m_timelineSvc
Definition: PrecedenceRulesGraph.h:264
concurrency::AlgorithmNode::getOutputDataNodes
const std::vector< DataNode * > & getOutputDataNodes() const
Get all supplier nodes.
Definition: PrecedenceRulesGraph.h:443
TimelineEvent::algorithm
std::string algorithm
Definition: ITimelineSvc.h:18
precedence::AlgoTraceProps
Definition: PrecedenceRulesGraph.h:30
precedence::EndTime::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:262
precedence::AlgoProps::m_algoIndex
int m_algoIndex
Definition: PrecedenceRulesGraph.h:62
concurrency::PrecedenceRulesGraph::m_algoCounter
unsigned int m_algoCounter
Total number of algorithm nodes in the graph.
Definition: PrecedenceRulesGraph.h:671
precedence::DecisionHubProps::m_allPass
bool m_allPass
Whether always passing regardless of daughter results.
Definition: PrecedenceRulesGraph.h:98
Cause::m_source
source m_source
Definition: PrecedenceRulesGraph.h:316
precedence::DecisionNegation::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:148
precedence::VertexName::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:110
concurrency::AlgorithmNode::m_inverted
bool m_inverted
Whether the selection result is negated or not.
Definition: PrecedenceRulesGraph.h:483
concurrency::DecisionNode::m_allPass
bool m_allPass
Whether always passing regardless of daughter results.
Definition: PrecedenceRulesGraph.h:403
precedence::CFDecision::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:176
concurrency::AlgorithmNode::getParentDecisionHubs
const std::vector< DecisionNode * > & getParentDecisionHubs() const
Get all parent decision hubs.
Definition: PrecedenceRulesGraph.h:436
precedence::CFDecision::operator()
std::string operator()(const DecisionHubProps &props) const
Definition: PrecedenceRulesGraph.h:171
TimelineEvent
Definition: ITimelineSvc.h:13
std::map< std::string, precedence::AlgoTraceVertex >
concurrency::AlgorithmNode::isIOBound
bool isIOBound() const
Check if algorithm is I/O-bound.
Definition: PrecedenceRulesGraph.h:460
std::stringstream
STL class.
concurrency::PrecedenceRulesGraph::~PrecedenceRulesGraph
~PrecedenceRulesGraph() override
Destructor.
Definition: PrecedenceRulesGraph.h:587
precedence::StartTime::m_timelineSvc
SmartIF< ITimelineSvc > m_timelineSvc
Definition: PrecedenceRulesGraph.h:237
concurrency::IGraphVisitor::visitEnter
virtual bool visitEnter(DecisionNode &) const
Definition: IGraphVisitor.h:17
std::string
STL class.
concurrency::AlgorithmNode::getAlgorithm
Algorithm * getAlgorithm() const
get Algorithm representatives
Definition: PrecedenceRulesGraph.h:453
precedence::StartTime::operator()
std::string operator()(const DecisionHubProps &) const
Definition: PrecedenceRulesGraph.h:233
precedence::AlgoTraceProps::AlgoTraceProps
AlgoTraceProps()
Definition: PrecedenceRulesGraph.h:31
precedence::DataProps::m_id
DataObjID m_id
Definition: PrecedenceRulesGraph.h:104
concurrency::ControlFlowNode::~ControlFlowNode
virtual ~ControlFlowNode()
Destructor.
Definition: PrecedenceRulesGraph.h:342
precedence::AllPass::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:160
concurrency::DecisionNode::m_modeOR
bool m_modeOR
Whether acting as "and" (false) or "or" node (true)
Definition: PrecedenceRulesGraph.h:401
precedence::FSMState::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:184
TimelineEvent::end
time_point end
Definition: ITimelineSvc.h:21
precedence::GroupLogic::operator()
std::string operator()(const AlgoProps &) const
Definition: PrecedenceRulesGraph.h:129
precedence::AlgoProps::m_name
std::string m_name
Definition: PrecedenceRulesGraph.h:60
precedence::Operations::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:298
precedence::FSMState::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:208
precedence::Duration::m_timelineSvc
SmartIF< ITimelineSvc > m_timelineSvc
Definition: PrecedenceRulesGraph.h:290
concurrency::AlgorithmNode::getRank
const float & getRank() const
Get Algorithm rank.
Definition: PrecedenceRulesGraph.h:450
precedence::VariantVertexProps
boost::variant< AlgoProps, DecisionHubProps, DataProps > VariantVertexProps
Definition: PrecedenceRulesGraph.h:307
precedence::GroupExit
Definition: PrecedenceRulesGraph.h:136
AlgsExecutionStates
The AlgsExecutionStates encodes the state machine for the execution of algorithms within a single eve...
Definition: AlgsExecutionStates.h:28
precedence::FSMState::operator()
std::string operator()(const DecisionHubProps &) const
Definition: PrecedenceRulesGraph.h:206
concurrency::PrecedenceRulesGraph::m_PRGraph
precedence::PRGraph m_PRGraph
BGL-based graph of precedence rules.
Definition: PrecedenceRulesGraph.h:683
concurrency::ControlFlowNode::m_graph
PrecedenceRulesGraph * m_graph
Definition: PrecedenceRulesGraph.h:355
Cause
Definition: PrecedenceRulesGraph.h:313
precedence::Duration::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:288
concurrency::DataNode::getPath
const DataObjID & getPath()
Definition: PrecedenceRulesGraph.h:504
concurrency::PrecedenceRulesGraph::m_headNode
DecisionNode * m_headNode
the head node of the control flow graph
Definition: PrecedenceRulesGraph.h:657
concurrency::ControlFlowNode::m_nodeIndex
unsigned int m_nodeIndex
Definition: PrecedenceRulesGraph.h:360
precedence::EndTime::operator()
std::string operator()(const DecisionHubProps &) const
Definition: PrecedenceRulesGraph.h:260
concurrency::DataNode::m_consumers
std::vector< AlgorithmNode * > m_consumers
Definition: PrecedenceRulesGraph.h:535
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
concurrency::PrecedenceRulesGraph::m_name
const std::string m_name
Definition: PrecedenceRulesGraph.h:675
std::ostringstream
STL class.
ITimelineSvc.h
concurrency::DecisionNode::getDaughters
const std::vector< ControlFlowNode * > & getDaughters() const
Get children nodes.
Definition: PrecedenceRulesGraph.h:389
concurrency::DataNode::accept
bool accept(IGraphVisitor &visitor)
Entry point for a visitor.
Definition: PrecedenceRulesGraph.h:507
CommonMessaging.h
precedence::EndTime::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:243
precedence::PrecTrace
boost::adjacency_list< boost::vecS, boost::vecS, boost::bidirectionalS, AlgoTraceProps > PrecTrace
Definition: PrecedenceRulesGraph.h:43
concurrency::DataNode::getConsumers
const std::vector< AlgorithmNode * > & getConsumers() const
Get all data object consumers.
Definition: PrecedenceRulesGraph.h:527
precedence::EndTime
Definition: PrecedenceRulesGraph.h:240
precedence::Duration::operator()
std::string operator()(const DecisionHubProps &) const
Definition: PrecedenceRulesGraph.h:286
concurrency::IGraphVisitor
Definition: IGraphVisitor.h:12
concurrency::DataNode::DataNode
DataNode(PrecedenceRulesGraph &graph, const DataObjID &path)
Constructor.
Definition: PrecedenceRulesGraph.h:502
precedence::DecisionHubProps::m_modePromptDecision
bool m_modePromptDecision
Whether to evaluate the hub decision ASA its child decisions allow to do that.
Definition: PrecedenceRulesGraph.h:94
precedence::CFDecision::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:166
precedence::AlgoProps::m_nodeIndex
int m_nodeIndex
Definition: PrecedenceRulesGraph.h:61
precedence::AlgoProps::m_allPass
bool m_allPass
Whether the selection result is relevant or always "pass".
Definition: PrecedenceRulesGraph.h:70
concurrency::PrecedenceRulesGraph::m_algoNameToAlgoOutputsMap
AlgoOutputsMap m_algoNameToAlgoOutputsMap
Definition: PrecedenceRulesGraph.h:666
precedence::FSMState::FSMState
FSMState(const EventSlot &slot)
Definition: PrecedenceRulesGraph.h:182
precedence::VertexName
Definition: PrecedenceRulesGraph.h:109
precedence::AlgoProps::m_inverted
bool m_inverted
Whether the selection result is negated or not.
Definition: PrecedenceRulesGraph.h:68
concurrency::PrecedenceRulesGraph::PrecedenceRulesGraph
PrecedenceRulesGraph(const std::string &name, SmartIF< ISvcLocator > svc)
Constructor.
Definition: PrecedenceRulesGraph.h:577
concurrency::DecisionNode::m_modePromptDecision
bool m_modePromptDecision
Whether to evaluate the hub decision ASA its child decisions allow to do that.
Definition: PrecedenceRulesGraph.h:399
concurrency::AlgorithmNode::m_algorithm
Algorithm * m_algorithm
Algorithm representative behind the AlgorithmNode.
Definition: PrecedenceRulesGraph.h:477
concurrency::DataNode::m_data_object_path
DataObjID m_data_object_path
Definition: PrecedenceRulesGraph.h:533
TimelineEvent::start
time_point start
Definition: ITimelineSvc.h:20
precedence::StartTime::StartTime
StartTime(SmartIF< ITimelineSvc > timelineSvc)
Definition: PrecedenceRulesGraph.h:214
concurrency::ControlFlowNode::m_nodeName
std::string m_nodeName
Definition: PrecedenceRulesGraph.h:361
concurrency::AlgorithmNode::m_rank
float m_rank
Algorithm rank of any kind.
Definition: PrecedenceRulesGraph.h:487
plotSpeedupsPyRoot.graph
graph
Definition: plotSpeedupsPyRoot.py:142
precedence::StartTime
Definition: PrecedenceRulesGraph.h:213
concurrency::PrecedenceRulesGraph
Definition: PrecedenceRulesGraph.h:573
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:78
precedence::Operations::operator()
std::string operator()(const DecisionHubProps &) const
Definition: PrecedenceRulesGraph.h:296
std::find
T find(T...args)
Gaudi::Functional::m_inputs
std::vector< InputHandle_t< In > > m_inputs
Definition: MergingTransformer.h:45
precedence::Duration::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:270
std::vector< int >
precedence::DecisionNegation
Definition: PrecedenceRulesGraph.h:147
concurrency::AlgorithmNode::m_inputs
std::vector< DataNode * > m_inputs
Algorithm inputs (DataNodes)
Definition: PrecedenceRulesGraph.h:494
concurrency::DecisionNode::m_modeConcurrent
bool m_modeConcurrent
Whether all daughters will be evaluated concurrently or sequentially.
Definition: PrecedenceRulesGraph.h:396
time_point
Clock::time_point time_point
Definition: ITimelineSvc.h:11
precedence::Operations
Definition: PrecedenceRulesGraph.h:293
concurrency::DataNode::m_producers
std::vector< AlgorithmNode * > m_producers
Definition: PrecedenceRulesGraph.h:534
precedence::StartTime::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:235
precedence::Operations::operator()
std::string operator()(const AlgoProps &props) const
Definition: PrecedenceRulesGraph.h:294
concurrency::ConditionNode
Definition: PrecedenceRulesGraph.h:538
precedence::DecisionNegation::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:152
concurrency::PrecedenceRulesGraph::m_nodeCounter
unsigned int m_nodeCounter
Total number of nodes in the graph.
Definition: PrecedenceRulesGraph.h:669
precedence::AlgoTraceProps::m_name
std::string m_name
Definition: PrecedenceRulesGraph.h:36
EventSlot
Class representing the event slot.
Definition: EventSlot.h:11
concurrency::IPrecedenceRulesGraph
Definition: PrecedenceRulesGraph.h:569
precedence::DecisionHubProps::DecisionHubProps
DecisionHubProps(const std::string &name, uint nodeIndex, bool modeConcurrent, bool modePromptDecision, bool modeOR, bool allPass)
Definition: PrecedenceRulesGraph.h:76
precedence::GroupExit::operator()
std::string operator()(const DecisionHubProps &props) const
Definition: PrecedenceRulesGraph.h:139
CommonMessaging
Definition: CommonMessaging.h:62
precedence::AlgoTraceProps::m_rank
int m_rank
Definition: PrecedenceRulesGraph.h:38
concurrency::AlgorithmNode
Definition: PrecedenceRulesGraph.h:413
MSG::ERROR
Definition: IMessageSvc.h:16
IGraphVisitor.h
concurrency::AlgorithmNode::isLiar
bool isLiar() const
Check if control flow logic is always inverted.
Definition: PrecedenceRulesGraph.h:465
precedence::AlgoTraceProps::m_runtime
int m_runtime
Definition: PrecedenceRulesGraph.h:39
precedence::GroupLogic
Definition: PrecedenceRulesGraph.h:128
concurrency::DataNode::m_graph
PrecedenceRulesGraph * m_graph
Definition: PrecedenceRulesGraph.h:530
concurrency::AlgorithmNode::AlgorithmNode
AlgorithmNode(PrecedenceRulesGraph &graph, Algorithm *algoPtr, unsigned int nodeIndex, unsigned int algoIndex, bool inverted, bool allPass)
Constructor.
Definition: PrecedenceRulesGraph.h:417
precedence::DecisionHubProps::m_modeOR
bool m_modeOR
Whether acting as "and" (false) or "or" node (true)
Definition: PrecedenceRulesGraph.h:96
concurrency::ControlFlowNode::getNodeName
const std::string & getNodeName() const
Get node name.
Definition: PrecedenceRulesGraph.h:352
precedence::AlgoProps::AlgoProps
AlgoProps()
Definition: PrecedenceRulesGraph.h:48
concurrency::ControlFlowNode::getNodeIndex
const unsigned int & getNodeIndex() const
Get node index.
Definition: PrecedenceRulesGraph.h:350
precedence::DecisionHubProps::m_modeConcurrent
bool m_modeConcurrent
Whether all daughters will be evaluated concurrently or sequentially.
Definition: PrecedenceRulesGraph.h:91
AlgsExecutionStates.h
precedence::AllPass
Definition: PrecedenceRulesGraph.h:155
precedence::DecisionHubProps
Definition: PrecedenceRulesGraph.h:75
precedence::GroupMode::operator()
std::string operator()(const DecisionHubProps &props) const
Definition: PrecedenceRulesGraph.h:120
precedence::EndTime::EndTime
EndTime(SmartIF< ITimelineSvc > timelineSvc)
Definition: PrecedenceRulesGraph.h:241
AlgsExecutionStates::State
State
Execution states of the algorithms.
Definition: AlgsExecutionStates.h:32
DataObjID::fullKey
std::string fullKey() const
Definition: DataObjID.cpp:54
ICondSvc.h
std::ostream
STL class.
precedence::GroupMode::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:125
concurrency::PrecedenceRulesGraph::name
const std::string & name() const override
Retrieve name of the service.
Definition: PrecedenceRulesGraph.h:626
concurrency::AlgorithmNode::m_isIOBound
bool m_isIOBound
If an algorithm is blocking.
Definition: PrecedenceRulesGraph.h:489
precedence::AllPass::operator()
std::string operator()(const DecisionHubProps &props) const
Definition: PrecedenceRulesGraph.h:158
precedence::Duration::Duration
Duration(SmartIF< ITimelineSvc > timelineSvc)
Definition: PrecedenceRulesGraph.h:268
precedence::FSMState::m_slot
EventSlot m_slot
Definition: PrecedenceRulesGraph.h:210
precedence::GroupMode::operator()
std::string operator()(const AlgoProps &) const
Definition: PrecedenceRulesGraph.h:118
EventSlot.h
precedence::VertexName::operator()
std::string operator()(const DataProps &props) const
Definition: PrecedenceRulesGraph.h:114
Cause::m_sourceName
std::string m_sourceName
Definition: PrecedenceRulesGraph.h:317
concurrency::AlgorithmNode::m_allPass
bool m_allPass
Whether the selection result is relevant or always "pass".
Definition: PrecedenceRulesGraph.h:485
precedence::AlgoTraceProps::m_index
int m_index
Definition: PrecedenceRulesGraph.h:37
concurrency::PrecedenceRulesGraph::m_algoNameToAlgoInputsMap
AlgoInputsMap m_algoNameToAlgoInputsMap
Indexes: maps of algorithm&#39;s name to algorithm&#39;s inputs/outputs.
Definition: PrecedenceRulesGraph.h:665
concurrency::DataNode::addProducerNode
void addProducerNode(AlgorithmNode *node)
Add relationship to producer AlgorithmNode.
Definition: PrecedenceRulesGraph.h:513
concurrency::DataNode::getProducers
const std::vector< AlgorithmNode * > & getProducers() const
Get all data object producers.
Definition: PrecedenceRulesGraph.h:525
concurrency::PrecedenceRulesGraph::m_dataPathToDataNodeMap
DataNodesMap m_dataPathToDataNodeMap
Index: map of data path to DataNode.
Definition: PrecedenceRulesGraph.h:663
concurrency::PrecedenceRulesGraph::getControlFlowNodeCounter
unsigned int getControlFlowNodeCounter() const
Get total number of control flow graph nodes.
Definition: PrecedenceRulesGraph.h:620
precedence::GroupExit::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:144
precedence::DataProps
Definition: PrecedenceRulesGraph.h:101
concurrency::ConditionNode::m_condSvc
SmartIF< ICondSvc > m_condSvc
Definition: PrecedenceRulesGraph.h:558
precedence::DecisionHubProps::m_nodeIndex
uint m_nodeIndex
Definition: PrecedenceRulesGraph.h:88
concurrency::PrecedenceRulesGraph::m_svcLocator
SmartIF< ISvcLocator > m_svcLocator
Service locator (needed to access the MessageSvc)
Definition: PrecedenceRulesGraph.h:674
concurrency::ConditionNode::ConditionNode
ConditionNode(PrecedenceRulesGraph &graph, const DataObjID &path, SmartIF< ICondSvc > condSvc)
Constructor.
Definition: PrecedenceRulesGraph.h:542
std::unordered_map< std::string, AlgorithmNode * >
precedence::DecisionHubProps::m_name
std::string m_name
Definition: PrecedenceRulesGraph.h:87
concurrency::PrecedenceRulesGraph::getHeadNode
DecisionNode * getHeadNode() const
Get head node.
Definition: PrecedenceRulesGraph.h:611
precedence::GroupLogic::operator()
std::string operator()(const DataProps &) const
Definition: PrecedenceRulesGraph.h:133
precedence::CFDecision::CFDecision
CFDecision(const EventSlot &slot)
Definition: PrecedenceRulesGraph.h:164
concurrency::DataNode::addConsumerNode
void addConsumerNode(AlgorithmNode *node)
Add relationship to consumer AlgorithmNode.
Definition: PrecedenceRulesGraph.h:519
concurrency::PrecedenceRulesGraph::m_decisionNameToDecisionHubMap
DecisionHubsMap m_decisionNameToDecisionHubMap
Index: map of decision&#39;s name to DecisionHub.
Definition: PrecedenceRulesGraph.h:661