Inheritance diagram for precedence.CruncherSequence:

Collaboration diagram for precedence.CruncherSequence:

Public Member Functions
	__init__ (self, timeValue, BlockingBoolValue, sleepFraction, cfgPath, dfgPath, topSequencer, showStat=False, timeline=False, outputLevel=INFO, cardinality=1)

	get (self)

Public Attributes
	cardinality = cardinality

	timeValue = timeValue

	BlockingBoolValue = BlockingBoolValue

	sleepFraction = sleepFraction

	cfg = nx.read_graphml(_buildFilePath(cfgPath))

	dfg = nx.read_graphml(_buildFilePath(dfgPath))

	enableTimeline = timeline

	outputLevel = outputLevel

	sequencer = self._generate_sequence(topSequencer)

Static Public Attributes
list	unique_sequencers = []

dict	dupl_seqs = {}

list	OR_sequencers = []

list	unique_algos = []

dict	dupl_algos = {}

list	unique_data_objects = []

Protected Member Functions
	_declare_data_deps (self, algo_name, algo)

	_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()

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.

    ):
        """
        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()

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

protected

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()

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

protected

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()

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 = BlockingBoolValue

Definition at line 201 of file precedence.py.

◆ cardinality

precedence.CruncherSequence.cardinality = cardinality

Definition at line 199 of file precedence.py.

◆ cfg

precedence.CruncherSequence.cfg = nx.read_graphml(_buildFilePath(cfgPath))

Definition at line 204 of file precedence.py.

◆ dfg

precedence.CruncherSequence.dfg = nx.read_graphml(_buildFilePath(dfgPath))

Definition at line 205 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 = timeline

Definition at line 207 of file precedence.py.

◆ OR_sequencers

precedence.CruncherSequence.OR_sequencers = []

static

Definition at line 171 of file precedence.py.

◆ outputLevel

precedence.CruncherSequence.outputLevel = outputLevel

Definition at line 209 of file precedence.py.

◆ sequencer

precedence.CruncherSequence.sequencer = self._generate_sequence(topSequencer)

Definition at line 212 of file precedence.py.

◆ sleepFraction

precedence.CruncherSequence.sleepFraction = sleepFraction

Definition at line 202 of file precedence.py.

◆ timeValue

precedence.CruncherSequence.timeValue = timeValue

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

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _declare_data_deps()

◆ _generate_sequence()

◆ get()

Member Data Documentation

◆ BlockingBoolValue

◆ cardinality

◆ cfg

◆ dfg

◆ dupl_algos

◆ dupl_seqs

◆ enableTimeline

◆ OR_sequencers

◆ outputLevel

◆ sequencer

◆ sleepFraction

◆ timeValue

◆ unique_algos

◆ unique_data_objects

◆ unique_sequencers

◆ init()