cmsRelvalreport.Profile Class Reference

Public Member Functions
def	__init__ (self, command, profiler, profile_name)
def	make_profile (self)
def	make_report (self, fill_db=False, db_name=None, tmp_dir=None, outdir=None, IgProf_option=None, metastring=None)

Public Attributes
	command
	profile_name
	profiler

Private Member Functions
def	_profile_edmsize (self)
def	_profile_igprof (self)
def	_profile_Memcheck_Valgrind (self)
def	_profile_None (self)
def	_profile_SimpleMem_Parser (self)
def	_profile_Timereport_Parser (self)
def	_profile_Timing_Parser (self)
def	_profile_valgrindfce (self)
def	_save_output (self)

Detailed Description

Class that represents the procedure of performance report creation

Definition at line 269 of file cmsRelvalreport.py.

Constructor & Destructor Documentation

def cmsRelvalreport.Profile.__init__	(		self,
			command,
			profiler,
			profile_name
	)

Definition at line 273 of file cmsRelvalreport.py.

    def __init__(self,command,profiler,profile_name):
        self.command=command
        self.profile_name=profile_name
        self.profiler=profiler
    

Member Function Documentation

def cmsRelvalreport.Profile._profile_edmsize (   self )

private

Launch edm size profiler

Definition at line 356 of file cmsRelvalreport.py.

References runall.testit.command, cmsswPreprocessor.CmsswPreprocessor.command, WorkFlow.WorkFlowBlock.command, cmsRelvalreport.Profile.command, cmsRelvalreport.execute(), cmsRelvalreport.Profile.profile_name, and cmsRelvalreport.Profile.profiler.

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_edmsize(self):
        '''
        Launch edm size profiler
        '''
        # In this case we replace the name to be clear
        input_rootfile=self.command
        
        # Skim the content if requested!
        if '.' in self.profiler:
            
            clean_profiler_name,options=self.profiler.split('.')
            content,nevts=options.split(',')
            outfilename='%s_%s.root'%(os.path.basename(self.command)[:-6],content)
            oldpypath=os.environ['PYTHONPATH']
            os.environ['PYTHONPATH']+=':%s' %MAKESKIMDRIVERDIR
            execute('%s -i %s -o %s --outputcommands %s -n %s' %(MAKESKIMDRIVER,
                                                                 self.command,
                                                                 outfilename,
                                                                 content,
                                                                 nevts)) 
            os.environ['PYTHONPATH']=oldpypath
            #execute('rm %s' %outfilename)
            self.command=outfilename
            self.profiler=clean_profiler_name
                                                                                                        
        
        profiler_line='edmEventSize -o %s -d %s'\
                            %(self.profile_name,self.command)
        
        return execute(profiler_line)
   

def cmsRelvalreport.Profile._profile_igprof (   self )

private

IgProf profiler launcher.

Definition at line 328 of file cmsRelvalreport.py.

References runall.testit.command, cmsswPreprocessor.CmsswPreprocessor.command, WorkFlow.WorkFlowBlock.command, cmsRelvalreport.Profile.command, cmsRelvalreport.execute(), cmsRelvalreport.Profile.profile_name, and cmsRelvalreport.Profile.profiler.

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_igprof(self): 
        '''
        IgProf profiler launcher.
        '''
        profiler_line=''
        
        igprof_options='igprof -d -t %s ' \
                    %EXECUTABLE # IgProf profile not general only for CMSRUN!
        
        # To handle Igprof memory and performance profiler in one function
        if self.profiler=='IgProf_perf':
            igprof_options+='-pp '
        elif self.profiler=='IgProf_mem':
            igprof_options+='-mp '
        else:
            raise 'Unknown IgProf flavour: %s !'
        igprof_options+='-z -o %s' %(self.profile_name)
        
        # If we are using cmsDriver we should use the prefix switch 
        if EXECUTABLE=='cmsRun' and self.command.find('cmsDriver.py')!=-1:
            profiler_line='%s --prefix "%s"' %(self.command,igprof_options) 
        else:
            profiler_line='%s %s' %(igprof_options, self.command)  
            
        return execute(profiler_line)
    

def cmsRelvalreport.Profile._profile_Memcheck_Valgrind (   self )

private

Valgrind Memcheck profile launcher

Definition at line 389 of file cmsRelvalreport.py.

References runall.testit.command, cmsswPreprocessor.CmsswPreprocessor.command, WorkFlow.WorkFlowBlock.command, cmsRelvalreport.Profile.command, cmsRelvalreport.execute(), and cmsRelvalreport.Profile.profile_name.

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_Memcheck_Valgrind(self):
        '''
        Valgrind Memcheck profile launcher
        '''
        profiler_line=''
        #Adding cms suppression of useless messages (cmsvgsupp)
        #Removing leak-checking (done with igprof)
        #'--leak-check=no '+\ (no is the default)
        #'--show-reachable=yes '+\
        #'--track-fds=yes '
        #Adding xml logging
        xmlFileName = self.profile_name.replace(",","-")[:-4] + ".xml"
        valgrind_options='time valgrind --track-origins=yes '+\
                               '--tool=memcheck `cmsvgsupp` '+\
                               '--num-callers=20 '+\
                               '--xml=yes '+\
                               '--xml-file=%s '%xmlFileName
        
        # If we are using cmsDriver we should use the prefix switch        
        if EXECUTABLE=='cmsRun' and self.command.find('cmsDriver.py')!=-1:
            #Replacing 2>&1 |tee with >& in the shell command to preserve the return code significance:
            # using tee return would be 0 even if the command failed before the pipe:
            profiler_line='%s --prefix "%s" >& %s' %(self.command,valgrind_options,self.profile_name)
                            
        else:                          
            profiler_line='%s %s >& %s' %(valgrind_options,self.command,self.profile_name)
                        #'--trace-children=yes '+\
        exec_status = execute(profiler_line)

        # compact the xml by removing the Leak_* errors
        if not exec_status:
            newFileName = xmlFileName.replace('valgrind.xml', 'vlgd.xml')
            compactCmd = 'xsltproc --output %s %s/test/filterOutValgrindLeakErrors.xsl %s' %(newFileName, valperf, xmlFileName)
            execute(compactCmd)
        
        return exec_status

def cmsRelvalreport.Profile._profile_None (   self )

private

Just Run the command!

Definition at line 456 of file cmsRelvalreport.py.

References runall.testit.command, cmsswPreprocessor.CmsswPreprocessor.command, WorkFlow.WorkFlowBlock.command, cmsRelvalreport.Profile.command, cmsRelvalreport.execute(), and cmsRelvalreport.Profile.make_report().

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_None(self):
        '''
        Just Run the command!
        '''
        return execute(self.command)
    

def cmsRelvalreport.Profile._profile_SimpleMem_Parser (   self )

private

Definition at line 432 of file cmsRelvalreport.py.

References cmsRelvalreport.Profile._save_output().

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_SimpleMem_Parser(self):
        return self._save_output()

def cmsRelvalreport.Profile._profile_Timereport_Parser (   self )

private

Definition at line 427 of file cmsRelvalreport.py.

References cmsRelvalreport.Profile._save_output().

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_Timereport_Parser(self):
        return self._save_output()
        

def cmsRelvalreport.Profile._profile_Timing_Parser (   self )

private

Definition at line 437 of file cmsRelvalreport.py.

References cmsRelvalreport.Profile._save_output().

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_Timing_Parser(self):
        return self._save_output()     
    

def cmsRelvalreport.Profile._profile_valgrindfce (   self )

private

Valgrind profile launcher.

Definition at line 305 of file cmsRelvalreport.py.

References runall.testit.command, cmsswPreprocessor.CmsswPreprocessor.command, WorkFlow.WorkFlowBlock.command, cmsRelvalreport.Profile.command, cmsRelvalreport.execute(), and cmsRelvalreport.Profile.profile_name.

Referenced by cmsRelvalreport.Profile.make_profile().

    def _profile_valgrindfce(self):
        '''
        Valgrind profile launcher.
        '''
        # ValgrindFCE needs a special library to run
        os.environ["VALGRIND_LIB"]=VFCE_LIB
        
        profiler_line=''
        valgrind_options= 'time valgrind '+\
                          '--tool=callgrind '+\
                          '--fce=%s ' %(self.profile_name)
        
        # If we are using cmsDriver we should use the prefix switch        
        if EXECUTABLE=='cmsRun' and self.command.find('cmsDriver.py')!=-1:
            profiler_line='%s --prefix "%s"' %(self.command,valgrind_options)
                            
        else:                          
            profiler_line='%s %s' %(valgrind_options,self.command)
                        #'--trace-children=yes '+\
        
        return execute(profiler_line)
    

def cmsRelvalreport.Profile._save_output (   self )

private

Save the output of cmsRun on a file!

Definition at line 442 of file cmsRelvalreport.py.

References runall.testit.command, cmsswPreprocessor.CmsswPreprocessor.command, WorkFlow.WorkFlowBlock.command, cmsRelvalreport.Profile.command, cmsRelvalreport.execute(), and cmsRelvalreport.Profile.profile_name.

Referenced by cmsRelvalreport.Profile._profile_SimpleMem_Parser(), cmsRelvalreport.Profile._profile_Timereport_Parser(), and cmsRelvalreport.Profile._profile_Timing_Parser().

    def _save_output(self):
        '''
        Save the output of cmsRun on a file!
        '''               
#         # a first maquillage about the profilename:
#         if self.profile_name[-4:]!='.log':
#             self.profile_name+='.log'
        #Replacing 2>&1 |tee with >& in the shell command to preserve the return code significance:
        # using tee return would be 0 even if the command failed before the pipe:
        profiler_line='%s  >& %s' %(self.command,self.profile_name)
        return execute(profiler_line)    

def cmsRelvalreport.Profile.make_profile

(

self

)

Launch the right function according to the profiler name.

Definition at line 280 of file cmsRelvalreport.py.

References cmsRelvalreport.Profile._profile_edmsize(), cmsRelvalreport.Profile._profile_igprof(), cmsRelvalreport.Profile._profile_Memcheck_Valgrind(), cmsRelvalreport.Profile._profile_None(), cmsRelvalreport.Profile._profile_SimpleMem_Parser(), cmsRelvalreport.Profile._profile_Timereport_Parser(), cmsRelvalreport.Profile._profile_Timing_Parser(), cmsRelvalreport.Profile._profile_valgrindfce(), and cmsRelvalreport.Profile.profiler.

    def make_profile(self):
        '''
        Launch the right function according to the profiler name.
        '''  
        if self.profiler=='ValgrindFCE':
            return self._profile_valgrindfce()
        elif self.profiler.find('IgProf')!=-1:
            return self._profile_igprof()    
        elif self.profiler.find('Edm_Size')!=-1:
            return self._profile_edmsize()
        elif self.profiler=='Memcheck_Valgrind':
            return self._profile_Memcheck_Valgrind()
        elif self.profiler=='Timereport_Parser':
            return self._profile_Timereport_Parser()
        elif self.profiler=='Timing_Parser':
            return self._profile_Timing_Parser()        
        elif self.profiler=='SimpleMem_Parser':
            return self._profile_SimpleMem_Parser()
        elif self.profiler=='':
            return self._profile_None()
        elif self.profiler=='None': #adding this for the case of candle ASCII file non-profiling commands
            return self._profile_None()
        else:
            raise 'No %s profiler found!'

def cmsRelvalreport.Profile.make_report	(		self,
			fill_db = False,
			db_name = None,
			tmp_dir = None,
			outdir = None,
			IgProf_option = None,
			metastring = None
	)

Make a performance report with CMSSW scripts for CMSSW internal profiling (Timing/SimpleMemoryCheck) and Memcheck, PR2 for edmEventSize and Callgrind (NOTE PR2 is not supported anymore and is not currently in the CMSSW external, running froma privat AFS!), igprof-analyse for all IgProf profiling.

Definition at line 470 of file cmsRelvalreport.py.

References cmsRelvalreport.execute(), ALCARECOTkAlBeamHalo_cff.filter, createfilelist.int, cmsRelvalreport.Profile.profile_name, cmsRelvalreport.Profile.profiler, python.rootplot.root2matplotlib.replace(), split, and harvestTrackValidationPlots.str.

Referenced by cmsRelvalreport.Profile._profile_None().

                    metastring=None):
        '''
        Make a performance report with CMSSW scripts for CMSSW internal profiling (Timing/SimpleMemoryCheck) and Memcheck, PR2 for edmEventSize and Callgrind (NOTE PR2 is not supported anymore and is not currently in the CMSSW external, running froma privat AFS!), igprof-analyse for all IgProf profiling.
        '''

        if outdir==None or outdir==self.profile_name:
            outdir=self.profile_name+'_outdir'
            
        #Create the directory where the report will be stored:
        if not os.path.exists(outdir) and not fill_db and not IgProf_option:
            #Added an IgProf condition to avoid the creation of a directory that we will not need anymore, since we will put all info in the filenames
            execute('mkdir %s' %outdir)
        
        if fill_db:
            db_option='-a'
            if not os.path.exists(db_name):
                db_option='-A'
        
        # temp in the local dir for PR
        tmp_switch=''    
        if tmp_dir!='':
            execute('mkdir %s' %tmp_dir)
            tmp_switch=' -t %s' %tmp_dir

        #Handle the various profilers:
        
        ##################################################################### 
        
        # Profiler is ValgrindFCE:
        if self.profiler=='ValgrindFCE':
            perfreport_command=''
            # Switch for filling the db
            if not fill_db:
                os.environ["PERFREPORT_PATH"]='%s/' %PERFREPORT2_PATH
                perfreport_command='%s %s -ff -i %s -o %s' %(PR2,
                                                             tmp_switch,
                                                             self.profile_name,
                                                             outdir)
            else:
                os.environ["PERFREPORT_PATH"]='%s/' %PERFREPORT3_PATH
                perfreport_command='%s %s -n5000 -u%s  -ff  -m \'scram_cmssw_version_string,%s\' -i %s %s -o %s' \
                                                    %(PR3,
                                                      tmp_switch,
                                                      PR3_PRODUCER_PLUGIN,
                                                      metastring,
                                                      self.profile_name,
                                                      db_option,
                                                      db_name)
            return execute(perfreport_command)
        
        #####################################################################            
            
        # Profiler is IgProf:
        if self.profiler.find('IgProf')!=-1:
            #First the case of IgProf PERF and MEM reporting:
            if not 'ANALYSE' in IgProf_option:
                #Switch to the use of igprof-analyse instead of PerfReport!
                #Will use the ANALYSE case for regressions between early event dumps and late event dumps of the profiles
                #Following Andreas suggestion, add the number of events for the EndOfJob report
                NumberOfEvents=self.command.split()[3] #FIXME: this is quite hardcoded... but should be stable...
                sqlite_outputfile=self.profile_name.split(".")[0].replace(IgProfProfiles[IgProf_option[0]],IgProf_option[0])+'___'+NumberOfEvents+'_EndOfJob.sql3'
                logger("Executing the report of the IgProf end of job profile")
                exit=execute('igprof-analyse --sqlite -d -v -g -r %s %s | sqlite3 %s'%(IgProf_option[0],self.profile_name,sqlite_outputfile)) 
                return exit
            #Then the "ANALYSE" case that we want to use to add to the same directories (Perf, MemTotal, MemLive)
            #also some other analyses and in particular:
            #1-the first 7 lines of the ASCII analysis of the IgProf profile dumps (total of the counters)
            #2-the dump at different event numbers,
            #3-the diff between the first and last dump,
            #4-the counters grouped by library using regexp at the last dump:
            else: #We use IgProf Analysis
                #Set the IgProfCounter from the ANALYSE.MEM_TOT style IgProf_option
                #print IgProf_option
                IgProfCounter=IgProf_option[1]
                #Add here the handling of the new IgProf.N.gz files so that they will get preserved and not overwritten:
                logger("Looking for IgProf intermediate event profile dumps")
                #Check if there are IgProf.N.gz dump files:
                IgProfDumps=glob.glob("IgProf.*.gz")
                #in case there are none check if they have already been mv'd to another name to avoid overwriting
                #(MEM_LIVE usually re-uses MEM_TOTAL, so the IgProf.N.gz files will already have a MemTotal name...)
                if not IgProfDumps:
                    localFiles=os.listdir('.')
                    IgProfDumpProfilesPrevious=re.compile(r"\w+.\d+.gz")
                    IgProfDumps=filter(lambda x: IgProfDumpProfilesPrevious.search(x),localFiles)
                #Now if there are dumps execute the following analyses:
                if IgProfDumps:
                    IgProfDumps.sort()
                    logger("Found the following IgProf intermediate event profile dumps:")
                    logger(IgProfDumps)
                    FirstDumpEvent=9999999
                    LastDumpEvent=0
                    exit=0
                    for dump in IgProfDumps:
                        if "___" in dump:
                            DumpEvent=dump.split(".")[0].split("___")[-1]
                        else:
                            DumpEvent=dump.split(".")[1]
                        #New naming convention using ___ as separator
                        DumpedProfileName=self.profile_name[:-3]+"___"+DumpEvent+".gz"
                        if dump.startswith("IgProf"):
                            execute('mv %s %s'%(dump,DumpedProfileName))
                        #Keep a tab of the first and last dump event for the diff analysis
                        if int(DumpEvent) < FirstDumpEvent:
                            FirstDumpEvent = int(DumpEvent)
                        if int(DumpEvent) > LastDumpEvent:
                            LastDumpEvent = int(DumpEvent)
                        #Eliminating the ASCII analysis to get the totals, Giulio will provide this information in igprof-navigator with a special query
                        #First type of analysis: dump first 7 lines of ASCII analysis:
                        #logger("Executing the igprof-analyse analysis to dump the ASCII 7 lines output with the totals for the IgProf counter")
                        #exit=execute('%s -o%s -i%s -t%s' %(IGPROFANALYS,outdir,DumpedProfileName,"ASCII"))
                        #Second type of analysis: dump the report in sqlite format to be ready to be browsed with igprof-navigator
                        logger("Executing the igprof-analyse analysis saving into igprof-navigator browseable SQLite3 format")
                        #exit=exit+execute('%s -o%s -i%s -t%s' %(IGPROFANALYS,outdir,DumpedProfileName,"SQLite3"))
                        #Execute all types of analyses available with the current profile (using the dictionary IgProfProfile):
                        #To avoid this we should use a further input in SimulationCandles.txt IgProfMem.ANALYSE.MEM_TOTAL maybe the cleanest solution.
                        #for IgProfile in IgProfCounters.keys():
                        #    if DumpedProfileName.find(IgProfile)>0:
                        #        for counter in IgProfCounters[IgProfile]:
                        #Check that the file does not exist:
                        #if not os.path.exists(DumpedProfileName.split(".")[0].replace(IgProfProfiles[counter],counter)+".sql3"):
                        exit=exit+execute('%s -c%s -i%s -t%s' %(IGPROFANALYS,IgProfCounter,DumpedProfileName,"SQLite3"))
                                    #else:
                                    #    print "File %s already exists will not process profile"%DumpedProfileName.split(".")[0].replace(IgProfProfiles[counter],counter)+".sql3"
                    #FIXME:
                    #Issue with multiple profiles in the same dir: assuming Perf and Mem will always be in separate dirs
                    #Potential ssue with multiple steps?
                    #Adapting to new igprof naming scheme:
                    FirstDumpProfile=self.profile_name[:-3]+"___"+str(FirstDumpEvent)+".gz"
                    LastDumpProfile=self.profile_name[:-3]+"___"+str(LastDumpEvent)+".gz"
                    #Third type of analysis: execute the diff analysis:
                    #Check there are at least 2 IgProf intermediate event dump profiles to do a regression!
                    if len(IgProfDumps)>1:
                        logger("Executing the igprof-analyse regression between the first IgProf profile dump and the last one")
                        #for IgProfile in IgProfCounters.keys():
                        #    if DumpedProfileName.find(IgProfile)>0:
                        #        IgProfCounter=IgProfCounters[IgProfile]
                        exit=exit+execute('%s -c%s -i%s -r%s' %(IGPROFANALYS,IgProfCounter,LastDumpProfile,FirstDumpProfile))
                    else:
                        logger("CANNOT execute any regressions: not enough IgProf intermediate event profile dumps!")
                    #Fourth type of analysis: execute the grouped by library igprof-analyse:
                    logger("Executing the igprof-analyse analysis merging the results by library via regexp and saving the result in igprof-navigator browseable SQLite3 format")
                    #for IgProfile in IgProfCounters.keys():
                    #        if DumpedProfileName.find(IgProfile)>0:
                    #            IgProfCounter=IgProfCounters[IgProfile]
                    exit=exit+execute('%s -c%s -i%s --library' %(IGPROFANALYS,IgProfCounter,LastDumpProfile))
                #If they are not there at all (no dumps)
                else:
                    logger("No IgProf intermediate event profile dumps found!")
                    exit=0
                
                return exit
                

        #####################################################################                     
            
        # Profiler is EdmSize:        
        if 'Edm_Size' in self.profiler:
            perfreport_command=''
            if not fill_db:
                os.environ["PERFREPORT_PATH"]='%s/' \
                                            %PERFREPORT2_PATH
                perfreport_command='%s %s -fe -i %s -o %s' \
                                            %(PR2,
                                              tmp_switch,
                                              self.profile_name,
                                              outdir)
            else:
                os.environ["PERFREPORT_PATH"]='%s/' \
                                            %PERFREPORT3_PATH
                perfreport_command='%s %s -n5000 -u%s -fe -i %s -a -o %s' \
                                            %(PR3,
                                              tmp_switch,
                                              PR3_PRODUCER_PLUGIN,
                                              self.profile_name,
                                              db_name)             

            return execute(perfreport_command)    

        #FIXME: probably need to move this somewhere else now that we use return statements
        if tmp_dir!='':
            execute('rm -r %s' %tmp_dir)
            
        #####################################################################    
                            
        # Profiler is Valgrind Memcheck
        if self.profiler=='Memcheck_Valgrind':
            # Three pages will be produced:
            os.environ['PERL5LIB']=PERL5_LIB
            report_coordinates=(VMPARSER,self.profile_name,outdir)
            # Copy the Valgrind Memcheck parser style file in the outdir
            copyStyleFile='cp -pR %s %s'%(VMPARSERSTYLE,outdir)
            execute(copyStyleFile)
            report_commands=('%s --preset +prod,-prod1 %s > %s/edproduce.html'\
                                %report_coordinates,
                             '%s --preset +prod1 %s > %s/esproduce.html'\
                                %report_coordinates,
                             '%s -t beginJob %s > %s/beginjob.html'\
                                %report_coordinates)
            exit=0
            for command in report_commands:
                exit= exit + execute(command)      
            return exit
        #####################################################################                
                
        # Profiler is TimeReport parser
        
        if self.profiler=='Timereport_Parser':
            return execute('%s %s %s' %(TIMEREPORTPARSER,self.profile_name,outdir))

        #####################################################################
        
        # Profiler is Timing Parser            
        
        if self.profiler=='Timing_Parser':
            return execute('%s -i %s -o %s' %(TIMINGPARSER,self.profile_name,outdir))
        
                    
        #####################################################################
        
        # Profiler is Simple memory parser
        
        if self.profiler=='SimpleMem_Parser':
            return execute('%s -i %s -o %s' %(SIMPLEMEMPARSER,self.profile_name,outdir))
            
        #####################################################################
        
        # no profiler
            
        if self.profiler=='' or self.profiler=='None': #Need to catch the None case, since otherwise we get no return code (crash for pre-requisite step running).
            return 0         #Used to be pass, but we need a return 0 to handle exit code properly!         
                                                                

Member Data Documentation

cmsRelvalreport.Profile.command

Definition at line 274 of file cmsRelvalreport.py.

Referenced by cmsRelvalreport.Profile._profile_edmsize(), cmsRelvalreport.Profile._profile_igprof(), cmsRelvalreport.Profile._profile_Memcheck_Valgrind(), cmsRelvalreport.Profile._profile_None(), cmsRelvalreport.Profile._profile_valgrindfce(), and cmsRelvalreport.Profile._save_output().

cmsRelvalreport.Profile.profile_name

Definition at line 275 of file cmsRelvalreport.py.

Referenced by cmsRelvalreport.Profile._profile_edmsize(), cmsRelvalreport.Profile._profile_igprof(), cmsRelvalreport.Profile._profile_Memcheck_Valgrind(), cmsRelvalreport.Profile._profile_valgrindfce(), cmsRelvalreport.Profile._save_output(), and cmsRelvalreport.Profile.make_report().

cmsRelvalreport.Profile.profiler

Definition at line 276 of file cmsRelvalreport.py.

Referenced by cmsRelvalreport.Profile._profile_edmsize(), cmsRelvalreport.Profile._profile_igprof(), cmsRelvalreport.Profile.make_profile(), and cmsRelvalreport.Profile.make_report().