precedence.CruncherSequence Class Reference

Inheritance diagram for precedence.CruncherSequence:

Collaboration diagram for 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
	unique_sequencers
	dupl_seqs
	OR_sequencers
	unique_algos
	dupl_algos
	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 166 of file precedence.py.

Constructor & Destructor Documentation

__init__()

def 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_PROJECT_SOURCE_DIR/GaudiHive/data path to GRAPHML file with control flow dependencies
dfgPath -- relative to $ENV_PROJECT_SOURCE_DIR/GaudiHive/data path to GRAPHML file with data flow dependencies
showStat -- print out statistics on precedence graph

Definition at line 177 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_PROJECT_SOURCE_DIR/GaudiHive/data path to GRAPHML file with control flow dependencies
        dfgPath -- relative to $ENV_PROJECT_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:
            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 precedence.CruncherSequence._declare_data_deps (   self,   algo_name,   algo  )

private

Declare data inputs and outputs for a given algorithm.

Definition at line 254 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 precedence.CruncherSequence._generate_sequence (   self,   name,   seq = None  )

private

Assemble the tree of sequencers.

Definition at line 275 of file precedence.py.

    def _generate_sequence(self, name, seq=None):
        """Assemble the tree of sequencers."""
 
        if not seq:
            seq = Gaudi__Sequencer(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.nodes[n]:
                # first rely on explicit type, if given
                algo_type = self.cfg.nodes[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 = Gaudi__Sequencer(algo_name, OutputLevel=INFO)
                if self.cfg.nodes[n].get("ModeOR") == "True":
                    self.OR_sequencers.append(n)
                    seq_daughter.ModeOR = True
                # if self.cfg.nodes[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.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 precedence.CruncherSequence.get

(

self

)

Definition at line 251 of file precedence.py.

    def get(self):
        return self.sequencer
 

Member Data Documentation

BlockingBoolValue

precedence.CruncherSequence.BlockingBoolValue

Definition at line 189 of file precedence.py.

cardinality

precedence.CruncherSequence.cardinality

Definition at line 187 of file precedence.py.

cfg

precedence.CruncherSequence.cfg

Definition at line 192 of file precedence.py.

dfg

precedence.CruncherSequence.dfg

Definition at line 193 of file precedence.py.

dupl_algos

precedence.CruncherSequence.dupl_algos

static

Definition at line 173 of file precedence.py.

dupl_seqs

precedence.CruncherSequence.dupl_seqs

static

Definition at line 170 of file precedence.py.

enableTimeline

precedence.CruncherSequence.enableTimeline

Definition at line 195 of file precedence.py.

OR_sequencers

precedence.CruncherSequence.OR_sequencers

static

Definition at line 171 of file precedence.py.

outputLevel

precedence.CruncherSequence.outputLevel

Definition at line 197 of file precedence.py.

sequencer

precedence.CruncherSequence.sequencer

Definition at line 200 of file precedence.py.

sleepFraction

precedence.CruncherSequence.sleepFraction

Definition at line 190 of file precedence.py.

timeValue

precedence.CruncherSequence.timeValue

Definition at line 188 of file precedence.py.

unique_algos

precedence.CruncherSequence.unique_algos

static

Definition at line 172 of file precedence.py.

unique_data_objects

precedence.CruncherSequence.unique_data_objects

static

Definition at line 175 of file precedence.py.

unique_sequencers

precedence.CruncherSequence.unique_sequencers

static

Definition at line 169 of file precedence.py.

---

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

• GaudiHive/python/GaudiHive/precedence.py