GaudiHive.precedence.CruncherSequence Class Reference

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, outputLevel=INFO)
def	get (self)

Public Attributes
	timeValue
	IOboolValue
	sleepFraction
	cfg
	dfg
	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 114 of file precedence.py.

Constructor & Destructor Documentation

def GaudiHive.precedence.CruncherSequence.__init__	(		self,
			timeValue,
			IOboolValue,
			sleepFraction,
			cfgPath,
			dfgPath,
			topSequencer,
			showStat = 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 125 of file precedence.py.

    def __init__(self, timeValue, IOboolValue, sleepFraction, cfgPath, dfgPath, topSequencer, showStat=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.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 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)

            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 192 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.)

                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.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.outputLevel

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