Inheritance diagram for GaudiHive.precedence.CruncherSequence:

Collaboration diagram for GaudiHive.precedence.CruncherSequence:

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

def	get (self)

Public Attributes
	timeValue

	IOboolValue

	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 124 of file precedence.py.

Constructor & Destructor Documentation

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

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

Definition at line 136 of file precedence.py.

                  showStat=False, timeline=False, outputLevel=INFO):
         """
         Keyword arguments:
         timeValue -- timeValue object to set algorithm execution time
         IOboolValue -- *BooleanValue object to set whether an algorithm has to experience IO-bound execution
         cfgPath -- relative to $GAUDIHIVEROOT/data path to GRAPHML file with control flow dependencies
         dfgPath -- relative to $GAUDIHIVEROOT/data path to GRAPHML file with data flow dependencies
         showStat -- print out statistics on precedence graph
         """
 
         self.timeValue = timeValue
         self.IOboolValue = IOboolValue
         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

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

private

Declare data inputs and outputs for a given algorithm.

Definition at line 185 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)
 

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

private

Assemble the tree of sequencers.

Definition at line 206 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]:
             if '/' in n:
                 algo_type, algo_name = n.split('/')
             else:
                 algo_type = 'GaudiAlgorithm'
                 algo_name = n
 
             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,
                                             OutputLevel=self.outputLevel,
                                             shortCalib=True,
                                             varRuntime=varRuntime,
                                             avgRuntime=avgRuntime,
                                             SleepFraction=self.sleepFraction if self.IOboolValue.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

def GaudiHive.precedence.CruncherSequence.get ( self )

Definition at line 181 of file precedence.py.

     def get(self):
 
         return self.sequencer

Member Data Documentation

GaudiHive.precedence.CruncherSequence.cfg

Definition at line 150 of file precedence.py.

GaudiHive.precedence.CruncherSequence.dfg

Definition at line 151 of file precedence.py.

dictionary GaudiHive.precedence.CruncherSequence.dupl_algos = {}

static

Definition at line 131 of file precedence.py.

dictionary GaudiHive.precedence.CruncherSequence.dupl_seqs = {}

static

Definition at line 128 of file precedence.py.

GaudiHive.precedence.CruncherSequence.enableTimeline

Definition at line 153 of file precedence.py.

GaudiHive.precedence.CruncherSequence.IOboolValue

Definition at line 147 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.OR_sequencers = []

static

Definition at line 129 of file precedence.py.

GaudiHive.precedence.CruncherSequence.outputLevel

Definition at line 155 of file precedence.py.

GaudiHive.precedence.CruncherSequence.sequencer

Definition at line 158 of file precedence.py.

GaudiHive.precedence.CruncherSequence.sleepFraction

Definition at line 148 of file precedence.py.

GaudiHive.precedence.CruncherSequence.timeValue

Definition at line 146 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_algos = []

static

Definition at line 130 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_data_objects = []

static

Definition at line 133 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_sequencers = []

static

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

Member Function Documentation

Member Data Documentation