def ReplayAllFile(self, options):
"""Replays all pinballs based on a partial file name.
@param options Options given on cmd line
@return exit code from replaying all pinballs
"""
if config.debug:
print('Replaying all pinballs matching patern.')
import glob
# If the user has given the "--all_file" option, then try to find all files
# with this string. Replay all the pinballs in these directories.
#
result = 0
if options.all_file:
param = {'options': options}
for path in glob.glob('*' + options.all_file + '*'):
pos = path.find(".address")
if pos != -1:
basename_file = path[0:pos]
self.Replay(param, '', basename_file)
# Wait until all the jobs complete.
#
if options.verbose:
msg.PrintMsg(
'Calling WaitJobs() from replay_dir.py, ReplayAllFile()')
result = util.WaitJobs(options)
return result
def VerifyLITFiles(self, sim_run_cmd, options):
"""
Use a simulator to verify all the LIT files for the tracing instance are valid.
"""
# Verify the LIT files for each directory.
#
# import pdb; pdb.set_trace()
result = 0
for lit_dir in util.GetLitDir():
if not options.list:
msg.PrintMsgPlus('Verifying files in dir: ' + lit_dir)
# import pdb; pdb.set_trace()
cmd = sim_run_cmd + ' --replay_dir ' + lit_dir
if options.sim_options:
cmd += ' --sim_options ' + options.sim_options
cmd += ' --verify'
cmd += util.AddGlobalFile(self.gv.DumpGlobalVars(), options)
cmd += util.AddCfgFile(options)
result = util.RunCmd(cmd, options, '',
concurrent=True) # Run jobs concurrently
if result != 0:
msg.PrintMsg('Error found during LIT file verification')
return result
# Wait for all the verification jobs to finish.
#
result = util.WaitJobs(options)
return result
def ReplayOne(self, options):
"""
Replays one set of pinballs. Calls Replay() with the pinball name.
@return exit code from replaying pinball
"""
param = {'options': options}
self.Replay(param, '', options.replay_file)
if options.verbose:
msg.PrintMsg('Calling WaitJobs() from replay_dir.py, ReplayOne()')
result = util.WaitJobs(options)
return result
def Run(self):
"""
Get the user's options, read config file and execute the phases desired by the user.
@return Exit code from last phase executed
"""
# Catch signals in order to do an orderly shutdown of the script.
#
self.InstallSigHandler()
# import pdb; pdb.set_trace()
options = self.ParseCommandLine()
# Print out the version numbers for all python modules in this directory.
#
if config.debug:
util.PrintModuleVersions()
# If logging, ensure the user has entered a mode.
#
if options.log and config.mode == '':
msg.PrintHelpAndExit(
'Must enter mode of application using: --mode "st|mt|mpi|mpi_mt"')
# Set the defaults for a set of variables which are needed, but not in the list
# of required options in the tracing configuration file.
#
self.SetDefaults(options)
# Create an new status file and zero out the file if it already exists.
# If user sets parameter 'append_status', the old file is not deleted.
#
util.NewStatusFile(options)
# Add 1500 to the warmup length in order to deal with problems that
# occur when the start of a warmup region and the end of the previous
# region are in the same basic block.
#
if not config.global_regions:
config.warmup_length += 1500
# Get variables used in many phases.
#
# import pdb; pdb.set_trace()
wp_pb_dir = util.GetWPDir()
log_file_name = util.GetLogFile()
# Print out the tracing configuration parameters.
#
if not options.list:
self.phases.PrintTracingInfo(options, wp_pb_dir, log_file_name,
self.PrintHome)
#########################################################################
#
# Several phases which clean up tracing instances.
#
#########################################################################
result = 0
if options.delete or options.delete_wp:
self.phases.DeleteTracingFileDir(options)
util.CheckResult(result, options, 'Deleting tracing instance files')
# Since just deleted all files/dirs for the tracing instance, need
# to set the whole program directory to the default value. Do NOT
# use util.GetWPDir() here because this may return the name of a
# relogged WP directory (which we, of course, just deleted.)
#
wp_pb_dir = util.GetBaseWPDir()
if options.delete_all:
self.phases.DeleteAllTracingFileDir(options)
util.CheckResult(result, options, 'Deleting all tracing files')
# Again, since just deleted all files/dirs, need to set the whole
# program directory to the default value.
#
wp_pb_dir = util.GetBaseWPDir()
# If the user has given the name of the whole program pinball
# directory, then save it. This must be done after the two delete
# phases because these phases delete this configuration file.
# Also, need to get default WP directory name in 'wp_pb_dir'.
#
# import pdb ; pdb.set_trace()
if hasattr(options, 'whole_pgm_dir') and options.whole_pgm_dir:
config.whole_pgm_dir = options.whole_pgm_dir
self.Config.SaveCfgParameter('whole_pgm_dir', options.whole_pgm_dir)
wp_pb_dir = util.GetWPDir()
#########################################################################
#
# Run the phases of the script. They are in a specific order to ensure
# all prerequisite phases are completed before a given phase is run.
#
#########################################################################
# Run the application without pin/pintools.
#
if options.native_pure:
util.PhaseBegin(options)
result = self.phases.NativePure(options)
util.CheckResult(
result, options,
'Pure native run %s' % config.PhaseStr(config.native_pure))
# Run the application using pin, but no pintools.
#
if options.native_pin:
util.PhaseBegin(options)
result = self.phases.NativePin(self.logger_cmd, wp_pb_dir, log_file_name, \
options)
util.CheckResult(result, options, 'Native run with pin only %s' % \
config.PhaseStr(config.native_pin))
# Logging phase to generate initial whole program pinballs.
#
# import pdb; pdb.set_trace()
if options.log or options.default_phases:
util.PhaseBegin(options)
result = self.phases.Logger(self.logger_cmd, wp_pb_dir, log_file_name, \
options)
util.CheckResult(result, options, 'Whole program pinball generation %s' % \
config.PhaseStr(config.log_whole))
# All phases after this require the whole program pinball directory. Exit with an
# error if it does not exist.
#
# import pdb; pdb.set_trace()
if not os.path.isdir(wp_pb_dir) and not options.list and not options.debug and\
not options.delete and not options.delete_all and not options.delete_wp and \
not options.native_pure and not options.native_pin:
string = '\nERROR: Can\'t proceed because the whole program pinball directory does not exist:\n' + \
' ' + wp_pb_dir + \
'\nMust select at least one phase to run. Try using option \'--default_phases\'.' + \
'\nUse \'-h\' for help on selecting phases to run.'
msg.PrintMsg(string)
# Use -1 to force check to fail
util.CheckResult(-1, options,
'Initial check to see if WP pinballs exist')
# Print out the number of instructions in the whole program pinballs.
#
if not options.list and os.path.isdir(wp_pb_dir):
msg.PrintMsg('')
msg.PrintMsg('Initial whole program pinball(s)')
util.PrintInstrCount(wp_pb_dir, options)
#########################################################################
#
# Phases which relog whole program pinballs using a filter to remove
# certain type of instructions (such as initialization or MPI spin).
#
# The relogging phases must be executed before the basic block vector
# generation phase. This must be done in case one, or more, relogging
# phases are executed. If so then, the BB vector phase needs to use
# the final relogged WP pinballs generated here.
#
#########################################################################
# If the user gives one, or more, of the use_relog_* options, they want
# to explictly define which filtered WP pinballs to use. As a result,
# unset the parameter 'relog_dir' just read from the per instance
# tracing configuration file and from the config object. This removes
# the previous "sticky" value for the filtered WP pinballs. Then use
# the WP pinball directory before any filters have been applied.
#
# import pdb; pdb.set_trace()
if cmd_options.UseRelogOptionsSet(options):
Config = config.ConfigClass()
Config.ClearCfgParameter('relog_dir')
config.relog_dir = ''
wp_pb_dir = util.GetBaseWPDir()
def FinalizeWPDir(wp_dir, string):
"""
Set the filtered WP pinball directory to be the new default WP dir
and print out the number of instructions in the newly filtered
pinballs.
"""
config.relog_dir = wp_dir
if not options.debug and not options.list:
# Only save this parameter if not just debugging or
# listing the commands to be run.
#
self.Config.SaveCfgParameter('relog_dir', wp_dir)
if not options.list and os.path.isdir(wp_dir):
msg.PrintMsg('')
msg.PrintMsg(string)
util.PrintInstrCount(wp_dir, options)
return
# The format of the code for each relogging (filtering) phase contains
# 3 components:
#
# 1) If going to use relogged WP pinballs for the phase (indicated by
# either 'relog_*' or 'use_relog_*' options), then get the
# appropriate WP directory name for this phase. Need to always do
# this, even when not relogging, because a previous run generated
# relogged WP pinballs.
#
# 2) If going to filter with relogging (indicated by a 'relog_*'
# option), then run the relogging phase.
#
# 3) Set the name of the default whole program pinball directory to
# the directory with the relogged WP pinballs.
# Relog with a user defined name for the relogged directory, and hopefully a set of
# knobs to define what action to take when relogging.
#
# import pdb; pdb.set_trace()
if options.use_relog_name != '' or options.relog_name:
relog_wp_dir = util.GetRelogPhaseDir(wp_pb_dir, config.RELOG_NAME,
options)
if options.relog_name:
if not options.list:
msg.PrintMsgDate('Filtering whole program pinballs with user defined name: %s %s' % \
(options.relog_name, config.PhaseStr(config.filter_user_defn)))
util.PhaseBegin(options)
result = self.phases.RelogWholeName(self.replay_cmd, wp_pb_dir,
relog_wp_dir, options)
if not options.list:
msg.PrintMsgDate('Finished filtering whole program pinballs with user defined name: %s %s' % \
(options.relog_name, config.PhaseStr(config.filter_user_defn)))
util.CheckResult(result, options, 'Filtering WP pinballs with user defined name: %s %s' % \
(options.relog_name, config.PhaseStr(config.filter_user_defn)))
# No errors, commit to using the new pinballs.
#
wp_pb_dir = relog_wp_dir
FinalizeWPDir(
relog_wp_dir,
'Whole program pinball(s) filtered with user defined name: ' +
options.relog_name)
# Relog with a focus thread.
#
if options.use_relog_focus or options.relog_focus:
relog_wp_dir = util.GetRelogPhaseDir(wp_pb_dir, config.RELOG_FOCUS,
options)
if options.relog_focus:
if not options.list:
msg.PrintMsgDate('Filtering whole program pinballs with a focus thread %s' % \
config.PhaseStr(config.filter_focus_thread))
# import pdb; pdb.set_trace()
util.PhaseBegin(options)
result = self.phases.RelogWholeFocus(self.replay_cmd,
wp_pb_dir, relog_wp_dir,
options)
if not options.list:
msg.PrintMsgDate('Finished filtering whole program pinballs with a focus thread %s' % \
config.PhaseStr(config.filter_focus_thread))
util.CheckResult(result, options, 'Filtering WP pinballs with focus thread %s' % \
config.PhaseStr(config.filter_focus_thread))
# No errors, commit to using the new pinballs.
#
wp_pb_dir = relog_wp_dir
FinalizeWPDir(
relog_wp_dir,
'Whole program pinball(s) filtered with a focus thread')
# If pinballs were relogged with a focus thread, then in the
# remaining phases the focus thread must be 0. Relogging generates
# per thread whole program pinballs (which only have thread 0). To
# enforce this, we change the focus_thread in the config object to
# be 0.
#
config.focus_thread = 0
# Also need to set options.use_relog_focus = True because we are will be using
# WP pinballs which have been relogged with a focus thread.
#
options.use_relog_focus = True
# Relog to remove initialization instructions. Do this before removing cleanup or
# MPI spin instructions.
#
# import pdb; pdb.set_trace()
if options.use_relog_no_init or options.relog_no_init:
relog_wp_dir = util.GetRelogPhaseDir(wp_pb_dir,
config.RELOG_NO_INIT, options)
if options.relog_no_init:
if not options.list:
msg.PrintMsgDate('Filtering whole program pinballs to remove initialization instructions %s' % \
config.PhaseStr(config.filter_init))
util.PhaseBegin(options)
result = self.phases.RelogWholeRemoveInit(self.replay_cmd,
wp_pb_dir,
relog_wp_dir, options)
if not options.list:
msg.PrintMsgDate('Finished filtering whole program pinballs to remove initialization instructions %s' % \
config.PhaseStr(config.filter_init))
util.CheckResult(result, options, 'Filtering WP pinballs to remove init instructions %s' % \
config.PhaseStr(config.filter_init))
# No errors, commit to using the new pinballs.
#
wp_pb_dir = relog_wp_dir
FinalizeWPDir(
relog_wp_dir,
'Whole program pinball(s) filtered to remove initialization instructions')
# Relog to remove cleanup instructions. Do this before removing MPI spin
# instructions.
#
# import pdb; pdb.set_trace()
if options.use_relog_no_cleanup or options.relog_no_cleanup:
relog_wp_dir = util.GetRelogPhaseDir(wp_pb_dir,
config.RELOG_NO_CLEANUP,
options)
if options.relog_no_cleanup:
if not options.list:
msg.PrintMsgDate('Filtering whole program pinballs to remove cleanup instructions %s' % \
config.PhaseStr(config.filter_cleanup))
util.PhaseBegin(options)
result = self.phases.RelogWholeRemoveCleanup(
self.replay_cmd, wp_pb_dir, relog_wp_dir, options)
if not options.list:
msg.PrintMsgDate('Finished filtering whole program pinballs to remove cleanup instructions %s' % \
config.PhaseStr(config.filter_cleanup))
util.CheckResult(result, options, 'Filtering WP pinballs to remove cleanup instructions %s' % \
config.PhaseStr(config.filter_cleanup))
# No errors, commit to using the new pinballs.
#
wp_pb_dir = relog_wp_dir
FinalizeWPDir(
relog_wp_dir,
'Whole program pinball(s) filtered to remove cleanup instructions')
# Relog to exclude code (instructions) between two addresses. Do this
# before removing MPI spin instructions.
#
# import pdb; pdb.set_trace()
if options.use_relog_code_exclude != '' or options.relog_code_exclude:
relog_wp_dir = util.GetRelogPhaseDir(wp_pb_dir,
config.RELOG_CODE_EXCLUDE,
options)
if options.relog_code_exclude:
if not options.list:
msg.PrintMsgDate('Filtering whole program pinballs with code exclusion %s' % \
config.PhaseStr(config.filter_code_exclude))
util.PhaseBegin(options)
result = self.phases.RelogWholeCodeExclude(
self.replay_cmd, wp_pb_dir, relog_wp_dir, options)
if not options.list:
msg.PrintMsgDate('Finished filtering whole program pinballs with code exclusion %s' % \
config.PhaseStr(config.filter_code_exclude))
util.CheckResult(result, options, 'Filtering WP pinballs with code exclusion %s' % \
config.PhaseStr(config.filter_code_exclude))
# No errors, commit to using the new pinballs.
#
wp_pb_dir = relog_wp_dir
FinalizeWPDir(
relog_wp_dir,
'Whole program pinball(s) filtered with code exclusion')
# Relog to remove OpenMP spin instructions.
#
# import pdb; pdb.set_trace()
if options.use_relog_no_omp_spin or options.relog_no_omp_spin:
relog_wp_dir = util.GetRelogPhaseDir(wp_pb_dir,
config.RELOG_NO_OMP_SPIN,
options)
if options.relog_no_omp_spin:
if not options.list:
msg.PrintMsgDate('Filtering whole program pinballs to remove OpenMP spin instructions %s' % \
config.PhaseStr(config.filter_OMP_spin))
util.PhaseBegin(options)
result = self.phases.RelogWholeRemoveOMPSpin(
self.replay_cmd, wp_pb_dir, relog_wp_dir, options)
if not options.list:
msg.PrintMsgDate('Finished filtering whole program pinballs to remove OpenMP spin instructions %s' % \
config.PhaseStr(config.filter_OMP_spin))
util.CheckResult(result, options, 'Filtering WP pinballs to remove OpenMP spin instructions %s' % \
config.PhaseStr(config.filter_OMP_spin))
# No errors, commit to using the new pinballs.
#
wp_pb_dir = relog_wp_dir
FinalizeWPDir(
relog_wp_dir,
'Whole program pinball(s) filtered to remove OpenMP spin instructions')
# Relog to remove MPI spin instructions.
#
# import pdb; pdb.set_trace()
if options.use_relog_no_mpi_spin or options.relog_no_mpi_spin:
relog_wp_dir = util.GetRelogPhaseDir(wp_pb_dir,
config.RELOG_NO_MPI_SPIN,
options)
if options.relog_no_mpi_spin:
if not options.list:
msg.PrintMsgDate('Filtering whole program pinballs to remove MPI spin instructions %s' % \
config.PhaseStr(config.filter_MPI_spin))
util.PhaseBegin(options)
result = self.phases.RelogWholeRemoveMPISpin(
self.replay_cmd, wp_pb_dir, relog_wp_dir, options)
if not options.list:
msg.PrintMsgDate('Finished filtering whole program pinballs to remove MPI spin instructions %s' % \
config.PhaseStr(config.filter_MPI_spin))
util.CheckResult(result, options, 'Filtering WP pinballs to remove MPI spin instructions %s' % \
config.PhaseStr(config.filter_MPI_spin))
# No errors, commit to using the new pinballs.
#
wp_pb_dir = relog_wp_dir
FinalizeWPDir(
relog_wp_dir,
'Whole program pinball(s) filtered to remove MPI spin instructions')
if not options.list:
msg.PrintMsgPlus(
'Using whole program pinballs in dir: ' + wp_pb_dir)
if (cmd_options.UseRelogOptionsSet(options) or \
cmd_options.RelogOptionsSet(options)) and \
os.path.isdir(wp_pb_dir):
msg.PrintMsg('')
util.PrintInstrCount(wp_pb_dir, options)
#########################################################################
#
# These phases are run with the whole progam pinballs defined/generated
# in the previous phases.
#
#########################################################################
# Make sure any relogged whole program pinball directory exist. Exit with an
# error if it does not exist.
#
# import pdb; pdb.set_trace()
if not os.path.isdir(wp_pb_dir) and not options.list and not options.debug and\
not options.delete and not options.delete_all and not options.delete_wp and \
not options.native_pure and not options.native_pin:
string = 'ERROR: Can\'t proceed because the whole program pinball directory does not exist:\n' + \
' ' + wp_pb_dir
msg.PrintMsg(string)
# Use -1 to force check to fail
util.CheckResult(-1, options,
'Second check to see if WP pinballs exist')
# Do not run replay whole program pinballs as one of the default
# phases. The user must explicitly include this option. This is to
# save time during the tracing process.
#
if options.replay:
if not options.list:
msg.PrintMsgDate('Replaying all whole program pinballs %s' % \
config.PhaseStr(config.replay_whole))
util.PhaseBegin(options)
result = self.phases.Replay(self.replay_cmd, wp_pb_dir, options)
if not options.list:
msg.PrintMsgDate('Finished replaying all whole program pinballs %s' % \
config.PhaseStr(config.replay_whole))
util.CheckResult(result, options, 'Replay of whole program pinballs %s' % \
config.PhaseStr(config.replay_whole))
# Generate basic block vectors.
#
if options.basic_block_vector or options.default_phases:
if not options.list:
msg.PrintMsgDate('Generating basic block vectors %s' % \
config.PhaseStr(config.gen_BBV))
util.PhaseBegin(options)
result = self.phases.BasicBlockVector(self.replay_cmd, wp_pb_dir,
options)
if result == 0:
result = util.WaitJobs(options)
if not options.list:
msg.PrintMsgDate('Finished basic block vector generation %s' % \
config.PhaseStr(config.gen_BBV))
util.CheckResult(result, options, 'Basic block vector generation %s' % \
config.PhaseStr(config.gen_BBV))
# Run Simpoints to genenerate representative regions.
#
if options.simpoint or options.default_phases:
if not options.list:
msg.PrintMsgDate('Running Simpoint on all processes %s' % \
config.PhaseStr(config.Simpoint))
# Setup dictionary of parameters for method RunAllDir()
#
msg.PrintMsg('fbm was in pinpoints')
param = {'options': options}
util.PhaseBegin(options)
result = util.RunAllDir(wp_pb_dir, self.phases.RunSimPoint, True,
param)
if not options.list:
msg.PrintMsgDate('Finished running Simpoint for all processes %s' % \
config.PhaseStr(config.Simpoint))
util.CheckResult(result, options, 'Simpoints generation %s' % \
config.PhaseStr(config.Simpoint))
# Relog to generate representative region pinballs.
#
if options.region_pinball or options.default_phases:
if not options.list:
msg.PrintMsgDate('Generating region pinballs %s' % \
config.PhaseStr(config.relog_regions))
util.PhaseBegin(options)
result = self.phases.MultiIterGenRegionPinballs(wp_pb_dir,
self.replayer_cmd,
options)
if result == 0:
if not options.list:
msg.PrintMsgPlus(
'Waiting on final concurrent region pinball generation')
result = util.WaitJobs(options)
if not options.list:
msg.PrintMsgDate('Finished generating region pinballs %s' % \
config.PhaseStr(config.relog_regions))
util.CheckResult(result, options, 'Region pinball generation %s' %\
config.PhaseStr(config.relog_regions))
# Do not run replay region pinballs as one of the default phases. The
# user must explicitly include this option. This is to save time
# during the tracing process.
#
if options.replay_region:
result = 0
if not options.list:
msg.PrintMsgDate('Replaying all region pinballs %s' % \
config.PhaseStr(config.replay_regions))
# import pdb; pdb.set_trace()
util.PhaseBegin(options)
for pp_dir in util.GetRegionPinballDir():
# Accumulate any errors which occur, but don't check for errors
# until all the pinballs have been replayed.
#
r = self.phases.Replay(self.replay_cmd, pp_dir, options)
result = result or r
if not options.list:
msg.PrintMsgDate('Finished replaying all region pinballs %s' % \
config.PhaseStr(config.replay_regions))
util.CheckResult(result, options, 'Replay of region pinballs %s' % \
config.PhaseStr(config.replay_regions))
result = 0 # Remove the return values from replaying region pinballs
# If there are any additional phases, then run them.
#
self.RunAdditionalPhases(wp_pb_dir, self.sim_replay_cmd, options)
# Cleanup and print out a string to indicate the tracing has completed.
#
# import pdb; pdb.set_trace()
util.CleanupTraceEnd(options)
util.PrintTraceEnd(options)
return result
def ProcessCommandLine(self, options):
"""
Replay pinballs using one of the 4 possible methods.
1) Replay one pinball
2) Replay all pinballs names whose name contains a string
3) Replay all pinballs in one directory
4) Replay all pinballs in the directories whose name contains a string
@param options Options given on cmd line
@return Exit code from replaying the last pinball
"""
# import pdb; pdb.set_trace()
result = 0
if options.replay_file:
result = self.ReplayOne(options)
elif options.replay_dir:
# Use util.RunAllDir() to execute the method Replay() on the
# pinballs in the directory 'replay_dir'. Pass no_glob = True so
# the directory name is NOT expanded.
#
param = {'options': options}
if options.verbose:
msg.PrintMsg(
'Calling util.RunAllDir() from replay_dir.py, ProcessCommandLine() replay_dir')
result = util.RunAllDir(options.replay_dir, self.Replay, True, param)
if result != 0:
return result
# Once all the jobs are started, then wait for them to finish
# before we proceed.
#
if options.verbose:
msg.PrintMsg(
'Calling WaitJobs() from replay_dir.py, ProcessCommandLine() replay_dir')
result = util.WaitJobs(options)
elif options.all_dir:
# Use util.RunAllDir() to execute the method Replay() on the
# pinballs in the directories which contain the string in
# options.alldir. Pass no_glob = False so the directory name IS
# expanded.
#
# import pdb; pdb.set_trace()
param = {'options': options}
if options.verbose:
msg.PrintMsg(
'Calling util.RunAllDir() from replay_dir.py, ProcessCommandLine() all_dir')
result = util.RunAllDir(options.all_dir, self.Replay, False, param)
if result != 0:
return result
# Once all the jobs are started, then wait for them to finish
# before we proceed.
#
if options.verbose:
msg.PrintMsg(
'Calling WaitJobs() from replay_dir.py, ProcessCommandLine() all_dir')
result = util.WaitJobs(options)
elif options.all_file:
result = self.ReplayAllFile(options)
else:
result = -1
return result
def RunAdditionalPhases(self, sim_replay_cmd, options, bin_options):
"""
Run the CBSP additional phases for SDE which are not run for PinPlay.
@param sim_replay_cmd Script which run the simulator on pinballs
@param options Options given on cmd line
@param options Options for each CBSP binary
@return Exit code from last phase executed
"""
# The SDE phases object needs an SDE kit object.
#
s_phases = sde_phases.SDEPhases()
kit_obj = self.GetKit()
s_phases.SetKit(kit_obj)
# Need the appropriate simulator kit too.
#
sim_kit = self.GetSimKit()
# Generate LMAT/LIT files
#
result = 0
if options.lit_gen or options.default_phases:
if not options.list:
msg.PrintMsgDate('Generating traces for region pinballs %s' % \
config.PhaseStr(config.LIT))
util.PhaseBegin(options)
for bopts in bin_options:
wp_dir = util.GetDefaultWPDir(bopts)
log_file_name = util.GetLogFile(bopts)
self.Config.SetPerBinParams(bopts)
result = s_phases.GenAllLitFiles(self.replayer_cmd, bopts)
if result == 0:
if not options.list:
msg.PrintMsgPlus('Waiting on final trace generation')
result = util.WaitJobs(options)
util.CheckResult(result, options, 'Traces for: %s %s' % \
(log_file_name, config.PhaseStr(config.LIT)), intermediate_phase=True)
if not options.list:
msg.PrintMsgDate('Finished generating traces for region pinballs %s' % \
config.PhaseStr(config.LIT))
util.CheckResult(result, options, 'Trace file generation %s' %\
config.PhaseStr(config.LIT))
# Run CMPSim simulator on region pinballs.
#
result = 0
if options.region_sim or options.default_phases:
# Print out CMPSim results every warmup_length instructions.
#
phase_length = options.warmup_length // config.instr_cmpsim_phase
if phase_length == 0:
phase_length = 1
for bopts in bin_options:
self.Config.SetPerBinParams(bopts)
for pp_dir in util.GetRegionPinballDir(bopts):
if not options.list:
msg.PrintMsgDate('Running CMPSim on region pinballs in dir: %s %s' % \
(pp_dir, config.PhaseStr(config.CMPsim_regions)))
util.PhaseBegin(options)
result = sim_kit.RunSimulator(pp_dir, sim_replay_cmd,
phase_length, bopts)
util.CheckResult(result, options, 'CMPSim for: %s %s' % \
(pp_dir, config.PhaseStr(config.CMPsim_regions)), intermediate_phase=True)
if not options.list:
msg.PrintMsgDate('Finished running CMPSim on region pinballs in dir %s %s' % \
(pp_dir, config.PhaseStr(config.CMPsim_regions)))
util.CheckResult(result, options, 'CMPSim on region pinballs: %s' % \
config.PhaseStr(config.CMPsim_regions))
# Run CMPSim simulator on whole program pinballs.
#
if options.whole_sim or options.default_phases:
# Set phase_length to print out CMPSim results every slice_size instructions.
#
phase_length = options.slice_size // config.instr_cmpsim_phase
if phase_length == 0:
phase_length = 1
for bopts in bin_options:
if not options.list:
msg.PrintMsgDate('Running CMPSim on whole program pinballs %s' % \
config.PhaseStr(config.CMPsim_whole))
util.PhaseBegin(options)
wp_dir = util.GetDefaultWPDir(bopts)
self.Config.SetPerBinParams(bopts)
result = sim_kit.RunSimulator(wp_dir, sim_replay_cmd,
phase_length, bopts)
util.CheckResult(result, options, 'CMPSim for: %s %s' % \
(wp_dir, config.PhaseStr(config.CMPsim_whole)), intermediate_phase=True)
if not options.list:
msg.PrintMsgDate('Finished running CMPSim on whole program pinballs %s' % \
config.PhaseStr(config.CMPsim_whole))
util.CheckResult(result, options, 'CMPSim on whole program pinballs %s' % \
config.PhaseStr(config.CMPsim_whole))
# Calculate prediction error from simulator data files.
#
if options.pred_error or options.default_phases:
if not options.list:
msg.PrintMsgDate('Calculating prediction error %s' % \
config.PhaseStr(config.pred_error))
util.PhaseBegin(options)
for bopts in bin_options:
wp_dir = util.GetDefaultWPDir(bopts)
result = s_phases.CalcPredError(wp_dir, sim_kit, bopts)
util.CheckResult(result, options, 'Prediction error for: %s %s' % \
(wp_dir, config.PhaseStr(config.pred_error)), intermediate_phase=True)
if not options.list:
msg.PrintMsgDate('Finished calculating prediction error %s' % \
config.PhaseStr(config.pred_error))
util.CheckResult(result, options, 'Prediction error calculation %s' % \
config.PhaseStr(config.pred_error))
# Assume nothing has gone wrong at this point.
#
return result
def GenAllLitFiles(self, replay_cmd, options):
"""
Generate LIT files and warmup LMAT files for all region pinballs in the tracing instance.
"""
result = 0
# Get the region pinball directories for this tracing instance.
#
# import pdb; pdb.set_trace()
pp_dirs = util.GetRegionPinballDir(options)
# Put the replay_cmd, options and flavor of files to generate into a
# directory because only one argument can be passed thru to the method
# GenLitFiles(), but three arguments need to be given to this method.
#
# Set the flavor to LMAT file generation.
#
param = {
'replay_cmd': replay_cmd,
'options': options,
'flavor': self.LMAT
}
# First generate LMAT files for each directory.
#
# import pdb; pdb.set_trace()
if hasattr(options, 'list') and not options.list:
msg.PrintMsgDate('Generating LMAT files')
for pdir in pp_dirs:
if not options.list:
msg.PrintMsgPlus(
'Generating LMAT files for pinballs in: ' + pdir)
result = util.RunAllDir(pdir, self.GenLitFiles, True, param)
if result != 0:
msg.PrintMsg('Error found during LIT file generation (1)')
return result
# Need to wait until all the LMAT jobs are complete before the
# LIT files are generated.
#
if hasattr(options, 'list') and not options.list:
msg.PrintMsgPlus('Waiting on concurrent LMAT file generation')
result = util.WaitJobs(options)
if hasattr(options, 'list') and not options.list:
msg.PrintMsgDate('Finished generating LMAT files')
# Now set the flavor for LIT file generation.
#
param['flavor'] = self.LIT
# Then generate LCAT files for each directory.
#
# import pdb; pdb.set_trace()
if hasattr(options, 'list') and not options.list:
msg.PrintMsgDate('Generating LIT files')
for pdir in pp_dirs:
if hasattr(options, 'list') and not options.list:
msg.PrintMsgPlus('Generating LIT files for pinballs in: ' + pdir)
result = util.RunAllDir(pdir, self.GenLitFiles, True, param)
if result != 0:
msg.PrintMsg('Error found during LIT file generation (2)')
return result
# Need to wait until all the LIT jobs are complete before continuing.
#
if hasattr(options, 'list') and not options.list:
msg.PrintMsgPlus('Waiting on concurrent LIT file generation')
result = util.WaitJobs(options)
if hasattr(options, 'list') and not options.list:
msg.PrintMsgDate('Finished generating LIT files')
return result
def RunAdditionalPhases(self, wp_pb_dir, sim_replay_cmd, options):
"""
Run the additional phases for SDE which are not run for PinPlay.
@param wp_pb_dir Directory containing whole program log files (pinballs)
@param sim_replay_cmd Python script used to replay a pinball with a simulator
@param options Options given on cmd line
@return Exit code from last phase executed
"""
# The SDE phases object needs an SDE kit object.
#
s_phases = sde_phases.SDEPhases()
kit_obj = self.GetKit()
s_phases.SetKit(kit_obj)
# Need the appropriate simulator kit too.
#
sim_kit = self.GetSimKit()
# Generate LMAT/LIT files.
#
result = 0
if options.lit_gen or options.default_phases:
if not options.list:
msg.PrintMsgDate('Generating traces for region pinballs %s' % \
config.PhaseStr(config.LIT))
util.PhaseBegin(options)
result = s_phases.GenAllLitFiles(self.replayer_cmd, options)
#if result == 0:
# if not options.list:
# msg.PrintMsgPlus('Waiting on final concurrent region pinball generation')
# result = util.WaitJobs(options)
if not options.list:
msg.PrintMsgDate('Finished generating traces for region pinballs %s' % \
config.PhaseStr(config.LIT))
util.CheckResult(result, options, 'Trace file generation %s' % \
config.PhaseStr(config.LIT))
# Generate traceinfo files.
#
if options.traceinfo or options.default_phases:
if not options.list:
msg.PrintMsgDate('Generating traceinfo files %s' % \
config.PhaseStr(config.traceinfo))
util.PhaseBegin(options)
result = s_phases.GenTraceinfoFiles(options)
if not options.list:
msg.PrintMsgDate('Finished generating traceinfo files %s' % \
config.PhaseStr(config.traceinfo))
util.CheckResult(result, options, 'Traceinfo file generation %s' % \
config.PhaseStr(config.traceinfo))
# Run CMPSim simulator on region pinballs.
#
if options.region_sim or options.default_phases:
# Print out CMPSim results every warmup_length instructions.
#
phase_length = options.warmup_length // config.instr_cmpsim_phase
if phase_length == 0:
phase_length = 1
for pp_dir in util.GetRegionPinballDir():
if not options.list:
msg.PrintMsgDate('Running CMPSim on region pinballs in dir: %s %s' % \
(pp_dir, config.PhaseStr(config.CMPsim_regions)))
util.PhaseBegin(options)
result = sim_kit.RunSimulator(pp_dir, sim_replay_cmd,
phase_length, options)
if not options.list:
msg.PrintMsgDate('Finished running CMPSim on region pinballs in dir %s %s' % \
(pp_dir, config.PhaseStr(config.CMPsim_regions)))
util.CheckResult(result, options, 'CMPSim on pinballs, dir: %s %s' % \
(pp_dir, config.PhaseStr(config.CMPsim_regions)))
# Run CMPSim simulator on whole program pinballs.
#
if options.whole_sim or options.default_phases:
# Set phase_length to print out CMPSim results every slice_size instructions.
#
phase_length = options.slice_size // config.instr_cmpsim_phase
if phase_length == 0:
phase_length = 1
if not options.list:
msg.PrintMsgDate('Running CMPSim on whole program pinballs %s' % \
config.PhaseStr(config.CMPsim_whole))
util.PhaseBegin(options)
result = sim_kit.RunSimulator(wp_pb_dir, sim_replay_cmd,
phase_length, options)
if not options.list:
msg.PrintMsgDate('Finished running CMPSim on whole program pinballs %s' % \
config.PhaseStr(config.CMPsim_whole))
util.CheckResult(result, options, 'CMPSim on whole program pinballs %s' % \
config.PhaseStr(config.CMPsim_whole))
# Calculate prediction error from simulator data files.
#
if options.pred_error or options.default_phases:
if not options.list:
msg.PrintMsgDate('Calculating prediction error %s' % \
config.PhaseStr(config.pred_error))
util.PhaseBegin(options)
result = s_phases.CalcPredError(wp_pb_dir, sim_kit, options)
if not options.list:
msg.PrintMsgDate('Finished calculating prediction error %s' % \
config.PhaseStr(config.pred_error))
util.CheckResult(result, options, 'Prediction error calculation %s' % \
config.PhaseStr(config.pred_error))
# Verify the LIT files with the simulator.
#
if options.verify:
if not options.list:
msg.PrintMsgDate('Verifying LIT files %s' % \
config.PhaseStr(config.verify_LIT))
util.PhaseBegin(options)
result = s_phases.VerifyLITFiles(self.sim_run_cmd, options)
if not options.list:
msg.PrintMsgDate('Finished verifying LIT files %s' % \
config.PhaseStr(config.verify_LIT))
util.CheckResult(result, options, 'LIT file verification %s' % \
config.PhaseStr(config.verify_LIT))
# Generate instruction mix for the whole program pinballs.
#
if options.imix_whole:
if not options.list:
msg.PrintMsgDate('Generating imix on whole program pinballs %s' % \
config.PhaseStr(config.imix_whole))
# Setup dictionary of parameters for method RunAllDir()
#
param = {'options': options, 'replayer_cmd': self.replayer_cmd}
util.PhaseBegin(options)
result = util.RunAllDir(wp_pb_dir, s_phases.GenImix, True, param)
if result == 0:
if not options.list:
msg.PrintMsgPlus(
'Waiting on final whole program pinball imix generation'
)
result = util.WaitJobs(options)
if not options.list:
msg.PrintMsgDate('Finished generating imix on whole program pinballs %s' % \
config.PhaseStr(config.imix_whole))
util.CheckResult(result, options, 'Imix on whole program pinballs %s' % \
config.PhaseStr(config.imix_whole))
# Generate instruction mix for the LIT files.
#
if options.imix_lit:
if not options.list:
msg.PrintMsgDate('Generating imix on LIT files %s' % \
config.PhaseStr(config.imix_lit))
# Setup dictionary of parameters for method RunAllDir()
#
param = {'options': options, 'replayer_cmd': self.replayer_cmd}
util.PhaseBegin(options)
for lit_dir in util.GetLitDir():
result = util.RunAllDir(lit_dir, s_phases.GenImix, True, param)
if result == 0:
if not options.list:
msg.PrintMsgPlus('Waiting on final LIT files generation')
result = util.WaitJobs(options)
if not options.list:
msg.PrintMsgDate('Finished generating imix on LIT files %s' % \
config.PhaseStr(config.imix_lit))
util.CheckResult(result, options, 'Imix on LIT files %s' % \
config.PhaseStr(config.imix_lit))
# Generate instruction mix for the region pinballs.
#
if options.imix_region:
if not options.list:
msg.PrintMsgDate('Generating imix on region pinballs %s' % \
config.PhaseStr(config.imix_regions))
# Setup dictionary of parameters for method RunAllDir()
#
param = {'options': options, 'replayer_cmd': self.replayer_cmd}
util.PhaseBegin(options)
for pp_dir in util.GetRegionPinballDir():
result = util.RunAllDir(pp_dir, s_phases.GenImix, True, param)
if result == 0:
if not options.list:
msg.PrintMsgPlus(
'Waiting on final region pinballs generation')
result = util.WaitJobs(options)
if not options.list:
msg.PrintMsgDate('Finished generating imix on region pinballs %s' % \
config.PhaseStr(config.imix_regions))
util.CheckResult(result, options, 'Imix on region pinballs %s' % \
config.PhaseStr(config.imix_regions))
# Assume nothing has gone wrong at this point.
#
return result
def RunSniper(pp_dir, sim_replay_cmd, phase_length, options):
def round(x, roundby=1000000):
return int(int((x / float(roundby))) * float(roundby))
# List of pinballs used to print Sniper output when all runs are complete.
#
pb_list = []
ret = 0
if not os.path.isdir(pp_dir):
# If running in MPI_MT_MODE, then it's possible for one process to not
# have a thread corresponding to the the current focus thread.
# However, another process might have this thread. Thus, only return
# an error if not tracing a MPI_MT application.
#
if options.mode == config.MPI_MT_MODE:
msg.PrintMsg('WARNING: Directory containing pinballs to run with simulator does not exist:\n ' + \
pp_dir)
msg.PrintMsg('Since tracing mode is \'mpi_mt\', this may be OK.')
return 0
else:
msg.PrintMsg('ERROR: Directory containing pinballs to run with simulator does not exist:\n ' + \
pp_dir)
return -1
# List of output sniper directories.
#
output_dir_list = []
for fn in os.listdir(pp_dir):
if fn.endswith('.address'):
pinball_path = os.path.join(pp_dir, os.path.splitext(fn)[0])
fn = os.path.splitext(fn)[0]
sniper_outputdir = os.path.join(config.sniper_result_dir,
pinball_path)
output_dir_list += [sniper_outputdir]
sniper_outputfile = pinball_path + config.sniper_out_ext
if options.debug:
# If debugging, check to see if the Sniper result files already exist for the pinball. If so,
# then print it out but don't run Sniper again.
#
if os.path.isdir(sniper_outputdir):
msg.PrintMsgPlus(
'WARNING: Skipping Sniper execution because output file already exists.\n'
' %s' % sniper_outputdir)
pb_list.append(pinball_path)
continue
# Select the proper config/options to run the desired version of
# Sniper/SniperLite.
#
# import pdb; pdb.set_trace()
if options.sniper_options:
common_sniper_opts = options.sniper_options
else:
if options.no_sniperlite:
common_sniper_opts = ''
else:
# use_orig = True # Use older SniperLite options
use_orig = False # New SniperLite options
if use_orig:
common_sniper_opts = ' -c dunnington -c cacheonly -c nehalem_cmpsim.cfg ' \
'-g --general/enable_icache_modeling=false ' \
'-g --perf_model/dram/direct_access=true ' \
'-g --perf_model/dram/queue_model/type=contention ' \
'-g --perf_model/dtlb/size=0'
else:
# Older patched Sniper 5.3
#
# common_sniper_opts = ' -c dunnington -c nehalem_cmpsim.cfg -c ccpp1c --pinball-non-sift \
# -g -replay:addr_trans -g --general/enable_icache_modeling=false'
# Newer patched Sniper 5.3
#
# common_sniper_opts = ' -c dunnington -c nehalem_cmpsim.cfg -c cc-fast --pinball-non-sift \
# -g -replay:addr_trans -g --general/enable_icache_modeling=false'
# Production SniperLite 6.0 options
#
common_sniper_opts = ' -c nehalem-lite --pinball-non-sift '
partial_run_cmd = (common_sniper_opts + ' --no-cache-warming')
try:
# If re.search() fails, code falls though to the exception.
#
warmup_region = re.search('warmup(\d+)_prolog(\d+)_region(\d+)_epilog(\d+)_(\d+)_(\d-\d+)', \
pinball_path)
# Get info on the length of regions in the pinball.
#
warmup = int(warmup_region.group(1))
prolog = int(warmup_region.group(2))
file_region = int(warmup_region.group(3))
epilog = int(warmup_region.group(4))
region_num = int(warmup_region.group(5))
weight = warmup_region.group(6).replace('-', '.')
icount = util.GetMaxIcount('', pinball_path)
sim_region_len = icount - warmup
calc_region = sim_region_len - prolog - epilog
if warmup != 0:
# If there are warmups, then need to use options to first do cache warmups in Sniper,
# then simulate the region.
#
partial_run_cmd = (common_sniper_opts + ' -s stop-by-icount:%d:%d ' \
% (sim_region_len, round(warmup)) + ' --roi-script ')
if not options.list:
# Print details about the various sections in the pinball.
#
msg.PrintMsgPlus('Running Sniper on: ' + fn)
msg.PrintMsg(' Warmup count: ' +
locale.format('%14d', warmup, True))
msg.PrintMsg(' Prolog count: ' +
locale.format('%14d', prolog, True))
msg.PrintMsg(' Actual region count: ' + locale.format('%14d', calc_region, True) + \
' (from file name: ' + locale.format('%d', file_region, True) + ')')
msg.PrintMsg(' Epilog count: ' +
locale.format('%14d', epilog, True))
msg.PrintMsg(' Total Instr count: ' +
locale.format('%14d', icount, True))
except AttributeError:
if 'whole_program' not in pinball_path:
# Whole program pinballs cannot be processed using the options
# given above (using -s stop-by-icount:) because they don't have
# warmup instructions to be skipped.
#
# Let the user know the results may be suspect because the dir
# appears to contain whole program pinballs, but the name doesn't
# contain the string 'whole_program'. However, don't flag this as
# an erorr. It's possible for the user to give the name of a WP
# pinball directory which does not contain this string.
#
msg.PrintMsgPlus(
'WARNING: This pinball may not really be a whole program pinball.\n'
' If this is true, the results may not be valid.\n'
' ' + pinball_path)
msg.PrintMsgPlus('Running Sniper on whole program pinball: ' +
pinball_path)
# Format the command and execute it asynchronously.
#
cmd = os.path.join(options.sniper_root, sim_replay_cmd) + partial_run_cmd + \
(' -d "%s" ' % sniper_outputdir) + ' --pinballs ' + pinball_path + \
' > ' + sniper_outputfile + ' 2>&1 '
pb_list.append(pinball_path)
end_str = fn
# import pdb; pdb.set_trace()
result = util.RunCmd(cmd, options, end_str, concurrent=True)
ret = result or ret
result = util.WaitJobs(options)
ret = result or ret
# Make sure some of the important Sniper output files exist for each pinball.
#
file_list = ['sim.stats.sqlite3', 'sim.info', 'sim.cfg', 'sim.out']
for sim_dir in output_dir_list:
for f in file_list:
if not os.path.isfile(os.path.join(sim_dir, f)):
msg.PrintMsg('\nERROR: Sniper output file does not exist:\n' \
' ' + os.path.join(sim_dir, f))
ret = -1
# Define a set of strings which can be ignored as errors if they occur in
# the output. These are special cases which must be added by hand when a
# new application is found that contains a string which might be detected
# as an erorr, but is a normal component of the output from running the
# application.
# Errors generated by Sniper itself which are acceptable.
#
ign_str = [
'void Sift::Writer::Sync(): Assertion',
'Sift::Reader::decodeInstruction'
]
pin_app_term = 'Pin app terminated abnormally'
ign_str += [pin_app_term]
# Strings generated by SPEC CPU2006 benchmarks: dealII-ref-1
#
ign_str += ['Estimated error=']
# Strings generated by MILC
#
ign_str += ['error_per_site', 'No O(a^2) errors', 'error_for_propagator']
# Print the output from running Sniper and look for errors in the output.
#
error = False
for pinball_path in pb_list:
# Get just the pinball name & print it
#
fn = os.path.split(pinball_path)[1]
sniper_outputfile = pinball_path + config.sniper_out_ext
if os.path.isfile(sniper_outputfile):
try:
f_stdout = open(sniper_outputfile, 'r')
except IOError:
msg.PrintMsg(
'ERROR: Can\'t open Sniper output file to look for errors.\n'
' ' + sniper_outputfile)
ret = -1
# Print the output file and look for errors.
#
if not options.list:
if 'whole_program' in pinball_path:
msg.PrintMsg('\nSniper output for: ' + pinball_path)
else:
msg.PrintMsg('\nSniper output for: ' + fn)
for line in f_stdout.readlines():
msg.PrintMsgNoCR(line)
if not options.ignore_sniper_error and \
('ERROR' in line or \
'error' in line or \
'Traceback' in line):
# Check to see if we can accept this line because
# it contains one of the strings we can ignore.
#
ok_ignore = False
for st in ign_str:
if st in line:
ok_ignore = True
break
if not ok_ignore:
# It's truly an error
#
error = True
# Need to print a msg indicating this error is OK to ignore.
#
if pin_app_term in line:
msg.PrintMsg(
'The \'Pin app terminated\' msg can be ignored. '
'It is not an error, just a warning.')
if error:
msg.PrintMsg('\nERROR: Sniper failed with an error.')
ret = -1
error = False # Reset in order to look for error in next pb
return ret
def Run(self):
"""
Get the user's options, read config file and execute the phases desired by the user.
@return Exit code from last phase executed
"""
# Catch signals in order to do an orderly shutdown of the script.
#
self.InstallSigHandler()
# import pdb; pdb.set_trace()
options, bin_options = self.ParseCommandLine()
# Print out the version numbers for all python modules in this directory.
#
if config.debug:
util.PrintModuleVersions()
# If logging, ensure the user has entered a mode.
#
if options.log and config.mode == '':
msg.PrintHelpAndExit(
'Must enter mode of application using: --mode "st|mt|mpi|mpi_mt"')
# Set the defaults for a set of variables which are needed, but not in the list
# of required options in the tracing configuration file.
#
self.SetDefaults(options)
# Add 1500 to the warmup length in order to deal with problems that
# occur when the start of a warmup region and the end of the previous
# region are in the same basic block.
#
config.warmup_length += 1500
# Get variables used in many phases.
#
# import pdb; pdb.set_trace()
wp_pb_dir = util.GetWPDir()
status_file = util.GetCBSPLogFile()
# Print out the tracing configuration parameters.
#
# TODO: Fix print so it prints CBSP info, not PP info
if not options.list:
self.phases.PrintTracingInfo(bin_options, wp_pb_dir,
status_file, self.PrintHome)
#########################################################################
#
# Several phases which clean up tracing instances.
#
#########################################################################
result = 0
if options.delete:
self.phases.DeleteTracingFileDir(options)
util.CheckResult(result, options, 'Deleting tracing instance files')
# Since just deleted all files/dirs for the tracing instance, need
# to set the whole program directory to the default value. Do NOT
# use util.GetWPDir() here because this may return the name of a
# relogged WP directory (which we, of course, just deleted.)
#
wp_pb_dir = util.GetBaseWPDir()
if options.delete_all:
self.phases.DeleteAllTracingFileDir(options)
util.CheckResult(result, options, 'Deleting all tracing files')
# Again, since just deleted all files/dirs, need to set the whole
# program directory to the default value.
#
wp_pb_dir = util.GetBaseWPDir()
#########################################################################
#
# Run the phases of the script. They are in a specific order to ensure
# all prerequisite phases are completed before a given phase is run.
#
#########################################################################
# Logging phase to generate initial whole program pinballs.
#
# import pdb; pdb.set_trace()
if options.log or options.default_phases:
util.PhaseBegin(options)
result = 0
# First check to make sure there aren't any old WP pinball directories.
#
for bopts in bin_options:
wp_pb_dir = util.GetDefaultWPDir(bopts)
if os.path.isdir(wp_pb_dir):
msg.PrintMsg(
"\nERROR: Whole program pinball directory already exists: "
+ wp_pb_dir +
"\nRemove this directory to proceed with generating "
"whole program pinballs.")
util.CheckResult(-1, options, 'Whole program pinball generation %s' % \
config.PhaseStr(config.log_whole))
for bopts in bin_options:
# Add CSBP logging specific knobs to any user defined
# log_options. They are required by this phase in order to
# generate DCFG files.
#
if not hasattr(options, 'log_options'):
setattr(options, 'log_options', '')
dcfg_log_opts = ' -omix %s.%s.mix' % (bopts.program_name, bopts.
input_name)
dcfg_log_opts += config.cbsp_base_log_options
if bopts.log_options:
bopts.log_options += dcfg_log_opts
else:
bopts.log_options = dcfg_log_opts
# Run the logger for this binary
#
wp_pb_dir = util.GetDefaultWPDir(bopts)
log_file_name = util.GetLogFile(bopts)
self.Config.SetPerBinParams(bopts)
result = self.phases.Logger(self.logger_cmd, wp_pb_dir,
log_file_name, bopts)
util.CheckResult(result, options, 'WP pinballs for: %s %s' % \
(log_file_name, config.PhaseStr(config.log_whole)), intermediate_phase=True)
# Now remove the DCFG log options as they are only used in this phase. This
# ensures only the user defined options are used for subsequent phases.
#
bopts.log_options = bopts.log_options.replace(dcfg_log_opts, '')
util.CheckResult(result, options, 'Whole program pinball generation %s' % \
config.PhaseStr(config.log_whole))
# All phases after this require the whole program pinball directories. Exit with an
# error if they don't not exist.
#
# import pdb; pdb.set_trace()
if not options.list and not options.debug and\
not options.delete and not options.delete_all:
err_msg = lambda string: msg.PrintMsg('\nERROR: Can\'t proceed because whole program pinball directory does not exist:\n' + \
' ' + string + \
'\nMust select at least one phase to run. Try using option \'--default_phases\'.' + \
'\nUse \'-h\' for help on selecting phases to run.')
for bopts in bin_options:
wp_dir = util.GetDefaultWPDir(bopts)
if not os.path.isdir(wp_dir):
err_msg(wp_dir)
# Use -1 to force check to fail
util.CheckResult(
-1, options,
'Initial check to see if WP pinballs exist')
# Print out the number of instructions in the whole program pinballs.
#
if not options.list:
for bopts in bin_options:
wp_dir = util.GetDefaultWPDir(bopts)
msg.PrintMsg('')
msg.PrintMsg(wp_dir)
util.PrintInstrCount(util.GetDefaultWPDir(bopts), options)
#########################################################################
#
# These phases are run with the whole progam pinballs defined/generated
# in the previous phase.
#
#########################################################################
# Run the cross binary matcher.
#
if options.cb_match or options.default_phases:
if not options.list:
msg.PrintMsgDate('Running cross binary matcher %s' % \
config.PhaseStr(config.cb_match))
msg.PrintMsg('')
util.PhaseBegin(options)
result = self.phases.CrossBinaryMatcher(self.path, self.script_path,
options, bin_options)
if not options.list:
msg.PrintMsgDate('Finished running cross binary matcher %s' % \
config.PhaseStr(config.cb_match))
util.CheckResult(result, options, 'Cross binary matcher %s' % \
config.PhaseStr(config.cb_match))
# Run Simpoints to generate clusters
#
if options.simpoint or options.default_phases:
if not options.list:
msg.PrintMsgDate('Running Simpoint %s' % \
config.PhaseStr(config.Simpoint))
param = {'options': options}
util.PhaseBegin(options)
result = self.phases.RunSimPoint(self.path, self.script_path,
options, bin_options)
if not options.list:
msg.PrintMsgDate('Finished running Simpoint %s' % \
config.PhaseStr(config.Simpoint))
util.CheckResult(result, options, 'Simpoints generation %s' % \
config.PhaseStr(config.Simpoint))
# Relog to generate representative region pinballs.
#
if options.region_pinball or options.default_phases:
if not options.list:
msg.PrintMsgDate('Generating region pinballs %s' % \
config.PhaseStr(config.relog_regions))
util.PhaseBegin(options)
result = 0
for bopts in bin_options:
wp_dir = util.GetDefaultWPDir(bopts)
log_file_name = util.GetLogFile(bopts)
self.Config.SetPerBinParams(bopts)
result = self.phases.MultiIterGenRegionPinballs(
wp_dir, self.replayer_cmd, bopts)
if result == 0:
if not options.list:
msg.PrintMsgPlus(
'Waiting on final concurrent region pinball generation')
result = util.WaitJobs(options)
util.CheckResult(result, options, 'Region pinballs for: %s %s' % \
(log_file_name, config.PhaseStr(config.relog_regions)), intermediate_phase=True)
if not options.list:
msg.PrintMsgDate('Finished generating region pinballs %s' % \
config.PhaseStr(config.relog_regions))
util.CheckResult(result, options, 'Region pinball generation %s' %\
config.PhaseStr(config.relog_regions))
# If there are any additional phases, then run them.
#
self.RunAdditionalPhases(self.sim_replay_cmd, options, bin_options)
# Cleanup and print out a string to indicate the tracing has completed.
#
# import pdb; pdb.set_trace()
util.CleanupTraceEnd(options)
util.PrintTraceEnd(options)
return result
