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