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, algoDebug=False)

def	get (self)

Public Attributes
	timeValue

	IOboolValue

	sleepFraction

	cfg

	dfg

	algoDebug

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

Constructor & Destructor Documentation

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

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

     def __init__(self, timeValue, IOboolValue, sleepFraction, cfgPath, dfgPath, topSequencer, showStat=False, algoDebug = False):
         """
         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.algoDebug = algoDebug
 
         # 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 172 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)
 
             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)
             algo.outKeys.append(dataName)
 
 

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

private

Assemble the tree of sequencers.

Definition at line 191 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 = DEBUG if self.algoDebug else INFO,
                                 shortCalib = True,
                                 varRuntime = varRuntime,
                                 avgRuntime = avgRuntime,
                                 SleepFraction = self.sleepFraction if self.IOboolValue.get() else 0.)
 
                 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 168 of file precedence.py.

     def get(self):
 
         return self.sequencer

Member Data Documentation

GaudiHive.precedence.CruncherSequence.algoDebug

Definition at line 142 of file precedence.py.

GaudiHive.precedence.CruncherSequence.cfg

Definition at line 139 of file precedence.py.

GaudiHive.precedence.CruncherSequence.dfg

Definition at line 140 of file precedence.py.

dictionary GaudiHive.precedence.CruncherSequence.dupl_algos = {}

static

Definition at line 121 of file precedence.py.

dictionary GaudiHive.precedence.CruncherSequence.dupl_seqs = {}

static

Definition at line 118 of file precedence.py.

GaudiHive.precedence.CruncherSequence.IOboolValue

Definition at line 136 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.OR_sequencers = []

static

Definition at line 119 of file precedence.py.

GaudiHive.precedence.CruncherSequence.sequencer

Definition at line 145 of file precedence.py.

GaudiHive.precedence.CruncherSequence.sleepFraction

Definition at line 137 of file precedence.py.

GaudiHive.precedence.CruncherSequence.timeValue

Definition at line 135 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_algos = []

static

Definition at line 120 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_data_objects = []

static

Definition at line 123 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_sequencers = []

static

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