Inheritance diagram for GaudiHive.precedence.CruncherSequence:

Collaboration diagram for GaudiHive.precedence.CruncherSequence:

Public Member Functions
def	__init__ (self, timeValue, BlockingBoolValue, sleepFraction, cfgPath, dfgPath, topSequencer, showStat=False, timeline=False, outputLevel=INFO, cardinality=1)

def	get (self)

Public Attributes
	cardinality

	timeValue

	BlockingBoolValue

	sleepFraction

	cfg

	dfg

	enableTimeline

	outputLevel

	sequencer

Static Public Attributes
list	unique_sequencers = []

dictionary	dupl_seqs = {}

list	OR_sequencers = []

list	unique_algos = []

dictionary	dupl_algos = {}

list	unique_data_objects = []

Private Member Functions
def	_declare_data_deps (self, algo_name, algo)

def	_generate_sequence (self, name, seq=None)

Detailed Description

Constructs the sequence tree of CPUCrunchers with provided control flow and data flow precedence rules.

Definition at line 163 of file precedence.py.

Constructor & Destructor Documentation

◆ init()

def GaudiHive.precedence.CruncherSequence.__init__	(	self,
		timeValue,
		BlockingBoolValue,
		sleepFraction,
		cfgPath,
		dfgPath,
		topSequencer,
		showStat = `False`,
		timeline = `False`,
		outputLevel = `INFO`,
		cardinality = `1`
	)

Keyword arguments:
timeValue -- timeValue object to set algorithm execution time
BlockingBoolValue -- *BooleanValue object to set whether an algorithm has to experience CPU-blocking execution
cfgPath -- relative to $ENV_CMAKE_SOURCE_DIR/GaudiHive/data path to GRAPHML file with control flow dependencies
dfgPath -- relative to $ENV_CMAKE_SOURCE_DIR/GaudiHive/data path to GRAPHML file with data flow dependencies
showStat -- print out statistics on precedence graph

Definition at line 174 of file precedence.py.

     def __init__(self,
                  timeValue,
                  BlockingBoolValue,
                  sleepFraction,
                  cfgPath,
                  dfgPath,
                  topSequencer,
                  showStat=False,
                  timeline=False,
                  outputLevel=INFO,
                  cardinality=1):
         """
         Keyword arguments:
         timeValue -- timeValue object to set algorithm execution time
         BlockingBoolValue -- *BooleanValue object to set whether an algorithm has to experience CPU-blocking execution
         cfgPath -- relative to $ENV_CMAKE_SOURCE_DIR/GaudiHive/data path to GRAPHML file with control flow dependencies
         dfgPath -- relative to $ENV_CMAKE_SOURCE_DIR/GaudiHive/data path to GRAPHML file with data flow dependencies
         showStat -- print out statistics on precedence graph
         """
  
         self.cardinality = cardinality
         self.timeValue = timeValue
         self.BlockingBoolValue = BlockingBoolValue
         self.sleepFraction = sleepFraction
  
         self.cfg = nx.read_graphml(_buildFilePath(cfgPath))
         self.dfg = nx.read_graphml(_buildFilePath(dfgPath))
  
         self.enableTimeline = timeline
  
         self.outputLevel = outputLevel
  
         # Generate control flow part
         self.sequencer = self._generate_sequence(topSequencer)
  
         if showStat:
             import pprint
  
             print("\n===== Statistics on Algorithms =====")
             print(
                 "Total number of algorithm nodes: ",
                 len(self.unique_algos) + sum(
                     [self.dupl_algos[i] - 1 for i in self.dupl_algos]))
             print("Number of unique algorithms: ", len(self.unique_algos))
             print("  -->", len(self.dupl_algos),
                   "of them being re-used with the following distribution: ",
                   [self.dupl_algos[i] for i in self.dupl_algos])
             # pprint.pprint(dupl_algos)
  
             print("\n===== Statistics on Sequencers =====")
             print(
                 "Total number of sequencers: ",
                 len(self.unique_sequencers) + sum(
                     [self.dupl_seqs[i] - 1 for i in self.dupl_seqs]))
             print("Number of unique sequencers: ", len(self.unique_sequencers))
             print("  -->", len(self.dupl_seqs),
                   "of them being re-used with the following distribution: ",
                   [self.dupl_seqs[i] for i in self.dupl_seqs])
             # pprint.pprint(dupl_seqs)
             print("Number of OR-sequencers: ", len(self.OR_sequencers))
  
             print("\n===== Statistics on DataObjects =====")
             print("Number of unique DataObjects: ",
                   len(self.unique_data_objects))
             # pprint.pprint(self.unique_data_objects)
             print()
  

Member Function Documentation

◆ _declare_data_deps()

def GaudiHive.precedence.CruncherSequence._declare_data_deps	(	self,
		algo_name,
		algo
	)

private

Declare data inputs and outputs for a given algorithm.

Definition at line 245 of file precedence.py.

     def _declare_data_deps(self, algo_name, algo):
         """ Declare data inputs and outputs for a given algorithm. """
  
         # Declare data inputs
         for inNode, outNode in self.dfg.in_edges(algo_name):
             dataName = inNode
             if dataName not in self.unique_data_objects:
                 self.unique_data_objects.append(dataName)
  
             if dataName not in algo.inpKeys:
                 algo.inpKeys.append(dataName)
  
         # Declare data outputs
         for inNode, outNode in self.dfg.out_edges(algo_name):
             dataName = outNode
             if dataName not in self.unique_data_objects:
                 self.unique_data_objects.append(dataName)
  
             if dataName not in algo.outKeys:
                 algo.outKeys.append(dataName)
  

◆ _generate_sequence()

def GaudiHive.precedence.CruncherSequence._generate_sequence	(	self,
		name,
		seq = `None`
	)

private

Assemble the tree of sequencers.

Definition at line 266 of file precedence.py.

     def _generate_sequence(self, name, seq=None):
         """ Assemble the tree of sequencers. """
  
         if not seq:
             seq = GaudiSequencer(name, ShortCircuit=False)
  
         for n in self.cfg[name]:
             # extract entity name and type
             algo_name = n.split('/')[1] if '/' in n else n
  
             if 'type' in self.cfg.node[n]:
                 # first rely on explicit type, if given
                 algo_type = self.cfg.node[n].get('type')
             else:
                 # if the type is not given explicitly, try to extract it from entity name,
                 # and, if unsuccessful, assume it is an algorithm
                 algo_type = n.split('/')[0] if '/' in n else 'Algorithm'
  
             if algo_type in ['GaudiSequencer', 'AthSequencer', 'ProcessPhase']:
                 if algo_name in ['RecoITSeq', 'RecoOTSeq', 'RecoTTSeq']:
                     continue
  
                 if n not in self.unique_sequencers:
                     self.unique_sequencers.append(n)
                 else:
                     if n not in self.dupl_seqs:
                         self.dupl_seqs[n] = 2
                     else:
                         self.dupl_seqs[n] += 1
  
                 seq_daughter = GaudiSequencer(algo_name, OutputLevel=INFO)
                 if self.cfg.node[n].get('ModeOR') == 'True':
                     self.OR_sequencers.append(n)
                     seq_daughter.ModeOR = True
                 # if self.cfg.node[n].get('Lazy') == 'False':
                 #    print "Non-Lazy - ", n
                 seq_daughter.ShortCircuit = False
                 if seq_daughter not in seq.Members:
                     seq.Members += [seq_daughter]
                     # iterate deeper
                     self._generate_sequence(n, seq_daughter)
             else:
                 #rndname = ''.join(random.choice(string.lowercase) for i in range(5))
                 #if algo_name in unique_algos: algo_name = algo_name + "-" + rndname
                 if n not in self.unique_algos:
                     self.unique_algos.append(n)
                 else:
                     if n not in self.dupl_algos:
                         self.dupl_algos[n] = 2
                     else:
                         self.dupl_algos[n] += 1
  
                 avgRuntime, varRuntime = self.timeValue.get(algo_name)
  
                 algo_daughter = CPUCruncher(
                     algo_name,
                     Cardinality=self.cardinality,
                     OutputLevel=self.outputLevel,
                     varRuntime=varRuntime,
                     avgRuntime=avgRuntime,
                     SleepFraction=self.sleepFraction
                     if self.BlockingBoolValue.get() else 0.,
                     Timeline=self.enableTimeline)
  
                 self._declare_data_deps(algo_name, algo_daughter)
  
                 if algo_daughter not in seq.Members:
                     seq.Members += [algo_daughter]
  
         return seq

◆ get()

def GaudiHive.precedence.CruncherSequence.get ( self )

Definition at line 241 of file precedence.py.

     def get(self):
  
         return self.sequencer

Member Data Documentation

◆ BlockingBoolValue

GaudiHive.precedence.CruncherSequence.BlockingBoolValue

Definition at line 186 of file precedence.py.

◆ cardinality

GaudiHive.precedence.CruncherSequence.cardinality

Definition at line 184 of file precedence.py.

◆ cfg

GaudiHive.precedence.CruncherSequence.cfg

Definition at line 189 of file precedence.py.

◆ dfg

GaudiHive.precedence.CruncherSequence.dfg

Definition at line 190 of file precedence.py.

◆ dupl_algos

dictionary GaudiHive.precedence.CruncherSequence.dupl_algos = {}

static

Definition at line 170 of file precedence.py.

◆ dupl_seqs

dictionary GaudiHive.precedence.CruncherSequence.dupl_seqs = {}

static

Definition at line 167 of file precedence.py.

◆ enableTimeline

GaudiHive.precedence.CruncherSequence.enableTimeline

Definition at line 192 of file precedence.py.

◆ OR_sequencers

list GaudiHive.precedence.CruncherSequence.OR_sequencers = []

static

Definition at line 168 of file precedence.py.

◆ outputLevel

GaudiHive.precedence.CruncherSequence.outputLevel

Definition at line 194 of file precedence.py.

◆ sequencer

GaudiHive.precedence.CruncherSequence.sequencer

Definition at line 197 of file precedence.py.

◆ sleepFraction

GaudiHive.precedence.CruncherSequence.sleepFraction

Definition at line 187 of file precedence.py.

◆ timeValue

GaudiHive.precedence.CruncherSequence.timeValue

Definition at line 185 of file precedence.py.

◆ unique_algos

list GaudiHive.precedence.CruncherSequence.unique_algos = []

static

Definition at line 169 of file precedence.py.

◆ unique_data_objects

list GaudiHive.precedence.CruncherSequence.unique_data_objects = []

static

Definition at line 172 of file precedence.py.

◆ unique_sequencers

list GaudiHive.precedence.CruncherSequence.unique_sequencers = []

static

Definition at line 166 of file precedence.py.

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

GaudiHive/python/GaudiHive/precedence.py

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _declare_data_deps()

◆ _generate_sequence()

◆ get()

Member Data Documentation

◆ BlockingBoolValue

◆ cardinality

◆ cfg

◆ dfg

◆ dupl_algos

◆ dupl_seqs

◆ enableTimeline

◆ OR_sequencers

◆ outputLevel

◆ sequencer

◆ sleepFraction

◆ timeValue

◆ unique_algos

◆ unique_data_objects

◆ unique_sequencers

◆ init()