GaudiHive.precedence.CruncherSequence Class Reference

Inheritance diagram for GaudiHive.precedence.CruncherSequence:

Collaboration diagram for GaudiHive.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
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 175 of file precedence.py.

Constructor & Destructor Documentation

__init__()

def GaudiHive.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 186 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:
            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

_declare_data_deps()

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

private

Declare data inputs and outputs for a given algorithm.

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

private

Assemble the tree of sequencers.

Definition at line 287 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 "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 = GaudiSequencer(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 GaudiHive.precedence.CruncherSequence.get

(

self

)

Definition at line 262 of file precedence.py.

    def get(self):
 
        return self.sequencer
 

Member Data Documentation

BlockingBoolValue

GaudiHive.precedence.CruncherSequence.BlockingBoolValue

Definition at line 198 of file precedence.py.

cardinality

GaudiHive.precedence.CruncherSequence.cardinality

Definition at line 196 of file precedence.py.

cfg

GaudiHive.precedence.CruncherSequence.cfg

Definition at line 201 of file precedence.py.

dfg

GaudiHive.precedence.CruncherSequence.dfg

Definition at line 202 of file precedence.py.

dupl_algos

dictionary GaudiHive.precedence.CruncherSequence.dupl_algos = {}

static

Definition at line 182 of file precedence.py.

dupl_seqs

dictionary GaudiHive.precedence.CruncherSequence.dupl_seqs = {}

static

Definition at line 179 of file precedence.py.

enableTimeline

GaudiHive.precedence.CruncherSequence.enableTimeline

Definition at line 204 of file precedence.py.

OR_sequencers

list GaudiHive.precedence.CruncherSequence.OR_sequencers = []

static

Definition at line 180 of file precedence.py.

outputLevel

GaudiHive.precedence.CruncherSequence.outputLevel

Definition at line 206 of file precedence.py.

sequencer

GaudiHive.precedence.CruncherSequence.sequencer

Definition at line 209 of file precedence.py.

sleepFraction

GaudiHive.precedence.CruncherSequence.sleepFraction

Definition at line 199 of file precedence.py.

timeValue

GaudiHive.precedence.CruncherSequence.timeValue

Definition at line 197 of file precedence.py.

unique_algos

list GaudiHive.precedence.CruncherSequence.unique_algos = []

static

Definition at line 181 of file precedence.py.

unique_data_objects

list GaudiHive.precedence.CruncherSequence.unique_data_objects = []

static

Definition at line 184 of file precedence.py.

unique_sequencers

list GaudiHive.precedence.CruncherSequence.unique_sequencers = []

static

Definition at line 178 of file precedence.py.

---

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

• GaudiHive/python/GaudiHive/precedence.py