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, 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 135 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 155 of file precedence.py.

                 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 217 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 238 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 self.cfg.node[n].has_key('type'):
                # 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,
                    OutputLevel=self.outputLevel,
                    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 213 of file precedence.py.

    def get(self):

        return self.sequencer

Member Data Documentation

GaudiHive.precedence.CruncherSequence.cfg

Definition at line 169 of file precedence.py.

GaudiHive.precedence.CruncherSequence.dfg

Definition at line 170 of file precedence.py.

dictionary GaudiHive.precedence.CruncherSequence.dupl_algos = {}

static

Definition at line 142 of file precedence.py.

dictionary GaudiHive.precedence.CruncherSequence.dupl_seqs = {}

static

Definition at line 139 of file precedence.py.

GaudiHive.precedence.CruncherSequence.enableTimeline

Definition at line 172 of file precedence.py.

GaudiHive.precedence.CruncherSequence.IOboolValue

Definition at line 166 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.OR_sequencers = []

static

Definition at line 140 of file precedence.py.

GaudiHive.precedence.CruncherSequence.outputLevel

Definition at line 174 of file precedence.py.

GaudiHive.precedence.CruncherSequence.sequencer

Definition at line 177 of file precedence.py.

GaudiHive.precedence.CruncherSequence.sleepFraction

Definition at line 167 of file precedence.py.

GaudiHive.precedence.CruncherSequence.timeValue

Definition at line 165 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_algos = []

static

Definition at line 141 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_data_objects = []

static

Definition at line 144 of file precedence.py.

list GaudiHive.precedence.CruncherSequence.unique_sequencers = []

static

Definition at line 138 of file precedence.py.

---

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

• GaudiHive/python/GaudiHive/precedence.py