def RunAdditionalPhases(self, wp_pb_dir, sim_replay_cmd, options):
"""
Run the additional phases for the simulator which are not run as
part of the usual PinPlay phases.
"""
phases_obj = phases.Phases()
self.sim_kit = self.GetSimKit()
msg.PrintMsg('sinuca_tracer_output: ' +
config.sinuca_tracer_output)
msg.PrintMsg('sinuca_tracer_threads: ' +
str(config.sinuca_tracer_threads))
msg.PrintMsg('sinuca_tracer_parallel_start: ' +
str(config.sinuca_tracer_parallel_start))
msg.PrintMsg('sinuca_tracer_parallel_end: ' +
str(config.sinuca_tracer_parallel_end))
if not options.sinuca_tracer_output:
msg.PrintMsgPlus('ERROR: Please set sinuca_tracer_output.')
util.CheckResult(
-1, options,
'Could not find the sinuca_tracer_output parameter.'
) # Force error with -1
# ~ # ~
if not options.sinuca_tracer_threads:
msg.PrintMsgPlus('ERROR: Please set sinuca_tracer_threads.')
util.CheckResult(
-1, options,
'Could not find the sinuca_tracer_threads parameter.'
) # Force error with -1
# ~ # ~
if not options.sinuca_tracer_parallel_start:
msg.PrintMsgPlus('ERROR: Please set sinuca_tracer_parallel_start.')
util.CheckResult(
-1, options,
'Could not find the sinuca_tracer_parallel_start parameter.'
) # Force error with -1
# ~ # ~
if not options.sinuca_tracer_parallel_end:
msg.PrintMsgPlus('ERROR: Please set sinuca_tracer_parallel_end.')
util.CheckResult(
-1, options,
'Could not find the sinuca_tracer_parallel_end parameter.'
) # Force error with -1
# Run branch predictor simulator on region pinballs.
#
if options.region_sim or options.default_phases:
# Print out simulator results every warmup_length instructions.
#
for pp_dir in util.GetRegionPinballDir():
phase_length = options.warmup_length
if phase_length == 0:
phase_length = options.slice_size
if not options.list:
msg.PrintMsgDate('Running simulator on region pinballs: %s' % \
config.PhaseStr(config.sim_regions))
util.PhaseBegin(options)
result = self.sim_kit.RunSimulator(pp_dir, sim_replay_cmd,
options)
if not options.list:
msg.PrintMsgDate('Finished running simulator on region pinballs: %s' % \
config.PhaseStr(config.sim_regions))
util.CheckResult(result, options, 'simulator on region pinballs: %s' % \
config.PhaseStr(config.sim_regions))
# Run branch predictor simulator on whole program pinballs.
#
if options.whole_sim or options.default_phases:
# Set phase_length to print out simulator results every slice_size instructions.
#
phase_length = options.slice_size
if not options.list:
msg.PrintMsgDate('Running simulator on whole program pinballs: %s' % \
config.PhaseStr(config.sim_whole))
util.PhaseBegin(options)
result = self.sim_kit.RunSimulator(wp_pb_dir, sim_replay_cmd,
options)
if not options.list:
msg.PrintMsgDate('Finished running simulator on whole program pinballs: %s' % \
config.PhaseStr(config.sim_whole))
util.CheckResult(result, options, 'simulator on whole program pinballs: %s' % \
config.PhaseStr(config.sim_whole))
return 0
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 RunSimPoint(self, kit_path, script_path, options, bin_options):
"""
Run Simpoint in the CBSP Data directory and generate weight files for
each binary in the respective binary Data directory.
@param kit_path Path to kit
@param script_path Explicit path to location in kit where scripts are located
@param options Options given on cmd line
@param bin_options List of options for each CBSP binary
@return exit code from Simpoint
"""
# Get CBSP Data directory and WP pinball basenames. For multi-process
# need to expand list returned by util.GetWPPinballs() to include all
# pinballs in each WP dir.
#
result = 0
cbsp_data_dir = util.GetCBSPDataDir(options)
wp_pinballs = [util.GetWPPinballs(bopt)[0] for bopt in bin_options]
wp_basenames = [
os.path.join(re.sub('whole_program.*/', '', pb))
for pb in wp_pinballs
]
# Go to CBSP Data directory to run Simpoint
#
orig_dir = os.getcwd()
if os.path.isdir(cbsp_data_dir):
os.chdir(cbsp_data_dir)
else:
msg.PrintMsg('ERROR: Unable to change to CBSP Data directory: ' +
cbsp_data_dir)
return -1
# Format the command to run simpoints.
# Use 'bin_options[0]' because parameter should be the same for all
# binaries.
#
sim_out_file = 'run_simpoint_out.txt'
if not options.list:
msg.PrintMsgDate('Running Simpoints for: %s' % options.cbsp_name)
msg.PrintMsgPlus('Simpoint output file (including errors): %s\n' %
os.path.join(cbsp_data_dir, sim_out_file))
if bin_options[0].simpoint_options:
msg.PrintMsgPlus(
'NOTE: Default options for Simpoint not used, only user defined options.'
)
cmd = 'simpoint ' + bin_options[0].simpoint_options
else:
if bin_options[0].maxk:
cmd = 'simpoint -k 2:%d -dim 100 -numInitSeeds 25 -fixedLength off -iters 500' % bin_options[
0].maxk
else:
cmd = 'simpoint -k 2:25 -dim 100 -numInitSeeds 25 -fixedLength off -iters 500'
cmd += ' -saveLabels labels.txt -saveSimpoints simpoints.txt -inputVectorsGzipped -loadFVFile matching-vec-profile.gz'
if options.list or options.debug:
msg.PrintMsg(cmd)
else:
fp_out = open(sim_out_file, 'w')
result = util.RunCmd(cmd,
options,
'',
f_stdout=fp_out,
f_stderr=fp_out)
fp_out.close()
if result != 0:
msg.PrintMsg('\nError found while running Simpoint in dir:\n'
' %s' % os.getcwd())
return result
# Generate the binary Data directories
#
bin_data_dir = []
for basename in wp_basenames:
name = os.path.join('..', '%s.Data' % basename)
bin_data_dir.append(name)
if not os.path.isdir(name):
try:
os.mkdir(name)
except OSError:
msg.PrintAndExit(
'method RunSimPoint(), Unable to make directory: ' +
name)
# Run command to generate weight files for the binaries
#
weight_out_file = 'generate_weights_out.txt'
cmd = os.path.join('make_simpoint_weights.py --weight_file_list ')
for data_dir in bin_data_dir:
cmd += ' %s/weights.txt' % data_dir
if not options.list:
msg.PrintMsgPlus(
'make_simpoint_weights.py output file (including errors): %s\n'
% os.path.join(cbsp_data_dir, weight_out_file))
if options.list or options.debug:
msg.PrintMsg(cmd)
else:
fp_out = open(weight_out_file, 'w')
result = util.RunCmd(cmd,
options,
'',
f_stdout=fp_out,
f_stderr=fp_out)
fp_out.close()
if result != 0:
msg.PrintMsg(
'\nError found while running make_simpoint_weights.py in dir:\n'
' %s' % os.getcwd())
return result
# Copy the simpoints and labels files to binary Data directories
#
#
def copy_file(f, d):
try:
shutil.copy(f, d)
return 0
except IOError:
msg.PrintMsg('\nError found in dir:\n'
' %s\nUnable to copy file:\n %s to %s' %
(os.getcwd(), f, d))
return -1
for data_dir in bin_data_dir:
result = copy_file('simpoints.txt', data_dir)
result = result | copy_file('labels.txt', data_dir)
if result != 0:
return result
# Generate the CSV files in each binary Data directory
#
for data_dir, basename in zip(bin_data_dir, wp_basenames):
# Go to the binary Data directory
#
old_dir = os.getcwd()
os.chdir(data_dir)
# Run the script to generate CSV files for this binary
#
bb_prof = os.path.join('..', cbsp_data_dir,
'%s.bb-profile.bz2' % basename)
csv_file = '%s.pinpoints.csv' % basename
if not options.list:
data_dir_rel_path = os.getcwd().replace(
os.path.join(orig_dir, ''), '')
msg.PrintMsgPlus(
'Any errors from running \'regions.py\' are in: %s' %
os.path.join(data_dir_rel_path, csv_file))
cmd = os.path.join('regions.py --csv_region --bbv_file %s' %
bb_prof)
cmd += ' --region_file=simpoints.txt --weight_file=weights.txt'
cmd += ' > %s 2>&1' % csv_file
msg.PrintMsg('')
if options.list or options.debug:
msg.PrintMsg(cmd)
else:
result = util.RunCmd(cmd, options, '')
if result != 0:
msg.PrintMsg(
'\nError found while generating CSV files in:\n %s' %
os.getcwd())
msg.PrintMsg('Error msgs in file: %s ' % csv_file)
return result
# Return to the CBSP Data directory
#
os.chdir(old_dir)
# Return to original directory
#
os.chdir(orig_dir)
if not options.list:
msg.PrintMsgDate('Finished running Simpoint for: ' +
options.cbsp_name)
return result
def Replay(self, param, dirname, filename):
"""
Replay a single pinball given the command line options and the name of
the pinball to replay. It formats the appropriate command line options,
saves global variables in a pickle file & calls the replayer script.
@param param Dictionary containing all parameters that need to be
passed into the method. Need a dictionary because this
method is sometimes called by walk_callback() which
only allows one parameter in the functions it calls.
@param dirname Directory where pinball is located
@param filename Pinball base file name
@return Exit code from the replayer script.
"""
if 'options' in param:
options = param['options']
else:
msg.PrintAndExit(
'method replay_dir.Replay() failed to get param \'options\'')
if options.verbose:
msg.PrintMsg('Start of Replay() in replay_dir.py')
# import pdb ; pdb.set_trace()
basename_file = os.path.join(dirname, filename)
command = self.replayer_cmd + ' --replay_file ' + basename_file
if options.verbose:
msg.PrintMsg("-> Replaying pinball \"" + basename_file + "\"")
if options.replay_options:
command += ' --replay_options "' + options.replay_options + '"'
# Check to see if need to add options for BB vector generation. Set
# 'log_opt' to any options the user may have put on the command line.
#
log_opt = options.log_options
if options.bb_add_filename:
file_name = os.path.basename(basename_file)
# If there is a focus thread, then need to remove the TID from the
# file name.
#
# NOTE: This code may need to be fixed when a method of running
# Simpoints on all threads of cooperative pinballs is implemented.
#
file_name = util.RemoveTID(file_name)
# Write BB vector files to the newly created *.Data directory.
#
data_dir = file_name + '.Data'
if not os.path.isdir(data_dir):
os.mkdir(data_dir)
log_opt += ' -o ' + os.path.join(data_dir, file_name)
# Check to see if need to add options when running a simulator.
#
# import pdb ; pdb.set_trace()
if options.sim_add_filename:
# Need to instantiate a kit of the type simulator being used.
# This is required on order to get some kit specific information.
#
# NOTE: If you are adding a kit for a new simulator, then you need
# to modify this code.
#
if config.sim_kit_type == config.BRPRED:
import brpred_kit
sim_kit = brpred_kit.BrPredKit()
elif config.sim_kit_type == config.SINUCA:
import sinuca_kit
sim_kit = sinuca_kit.Sinuca_TracerKit()
elif config.sim_kit_type == config.CMPSIM:
import sde_cmpsim_kit
sim_kit = sde_cmpsim_kit.CMPsimKit()
else:
msg.PrintAndExit('Undefined kit type in method replay_dir.Replay(): ' + \
str(config.sim_kit_type))
# Add the simulator knob to specify the file for the output from
# the simulator.
#
# ~ log_opt += ' ' + sim_kit.GetSimOutputFile(basename_file)
# When 'log_opt' is added to the command line below, it will
# put double quotes (") around all the options. Therefore, need to
# remove any exising double quotes in the current value for the
# string 'log_opt'.
#
log_opt = log_opt.replace('"', '')
# If relogging WP pinballs, need to add the -log:basename knob with
# the relogged pinball path/name.
#
# import pdb ; pdb.set_trace()
if options.wp_relog_dir:
ft = util.GetFocusThreadPB(basename_file)
if ft > -1 and not options.relog_focus:
# If WP pinballs were relogged with a focus thread, then the
# resulting pinballs were 'per thread', not 'cooperative'. If
# relogging with a different filter (i.e. options.relog_focus ==
# False) then need to remove TID from base file name given to
# the knob -log:basename.
#
file_name = os.path.basename(util.RemoveTID(basename_file))
else:
file_name = os.path.basename(basename_file)
log_opt += ' -log:basename ' + os.path.join(options.wp_relog_dir,
file_name)
if not options.list:
msg.PrintMsgDate('Relog whole program pinball: ' + file_name)
if log_opt:
command += ' --log_options "' + log_opt + '"'
if options.playout:
command += ' --playout '
# if not options.list:
# msg.PrintMsg(command)
# If not just listing the command, then dump the global
# variables so the next Python script can have access to them.
# Then run the script.
#
result = 0
if not options.list:
# Dump the global data to a unique file name. Need to add the
# option --global_file with this unique file name to options when
# calling a script.
#
gv = config.GlobalVar()
command += util.AddGlobalFile(gv.DumpGlobalVars(), options)
command += util.AddCfgFile(options)
result = util.RunCmd(command, options, filename,
concurrent=True) # Run concurrent jobs here
else:
# If the option 'list' is defined, then just list out the
# commands to be exectuted, but don't execute them.
#
msg.PrintMsg(command)
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 CrossBinaryMatcher(self, kit_path, script_path, options, bin_options):
"""
Run the cross binary matcher on all the binaries in the CBSP experiment.
NOTE: Only works if there is only one WP pinball in each WP pinball
directory (i.e. will NOT work with multipe process applications).
@param options Options given on cmd line
@param kit_path Path to kit
@param script_path Explicit path to location in kit where scripts are located
@param bin_options List of options for each CBSP binary
@return error_code
"""
# Get CBSP Data directory and WP pinball basenames. NOTE: For expanding
# this code to work with multi-process WP pinballs, need to expand list
# returned by util.GetWPPinballs() to include all pinballs in each WP
# dir.
#
result = 0
cbsp_data_dir = util.GetCBSPDataDir(options)
wp_pinballs = []
for bopt in bin_options:
pb = util.GetWPPinballs(bopt)
if not pb:
return -1
wp_pinballs.append(pb[0])
wp_basenames = [
os.path.join(re.sub('whole_program.*/', '', pb))
for pb in wp_pinballs
]
# Go to CBSP Data directory to run matcher
#
orig_dir = os.getcwd()
if os.path.isdir(cbsp_data_dir):
os.chdir(cbsp_data_dir)
else:
msg.PrintMsg('ERROR: Unable to change to CBSP Data directory: ' +
cbsp_data_dir)
return -1
# Matcher output file
#
output_file = 'crossBinaryMatcher_out.txt'
try:
fp_out = open(output_file, 'w')
except IOError:
msg.PrintMsg(
'ERROR: Failed to open cross binary matcher output file:\n'
' ' + output_file)
return -1
# Format cross binary matcher command & execute.
# Use 'bin_options[0]' because parameter should be the same for all
# binaries.
#
if not options.list:
msg.PrintMsgDate('Running cross binary matcher for: ' +
options.cbsp_name)
msg.PrintMsgPlus(
'Cross binary matcher output file (including errors): %s\n' %
os.path.join(cbsp_data_dir, output_file))
cmd = 'crossBinMatcher -graphm_config %s' % os.path.join(
kit_path, script_path, 'graphm.config.txt')
cmd += ' -slice_size %s' % str(bin_options[0].slice_size)
for pb, basename in zip(wp_pinballs, wp_basenames):
cmd += ' %s.{dcfg.json,trace.json}.bz2 ' % os.path.join('..', pb)
cmd += ' %s.bb-profile.bz2 ' % (basename)
if options.list or options.debug:
msg.PrintMsg(cmd)
else:
result = util.RunCmd(cmd,
options,
'',
f_stdout=fp_out,
f_stderr=fp_out)
fp_out.close()
if not options.list:
msg.PrintMsgDate('Finished running cross binary matcher for: ' +
options.cbsp_name)
# Return to original directory
#
os.chdir(orig_dir)
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 RunAdditionalPhases(self, wp_pb_dir, sim_replay_cmd, options):
"""Run the additional phases for SDE which are not run for PinPlay."""
if not options.sniper_root or not os.path.exists(
os.path.join(options.sniper_root, 'run-sniper')):
msg.PrintMsgPlus(
'ERROR: Please set SNIPER_ROOT or --sniper_root to a valid Sniper install.'
)
util.CheckResult(
-1, options,
'Checking for Sniper install location.') # Force error with -1
if options.region_sim or options.default_phases:
# Print out Sniper results every warmup_length instructions.
#
for pp_dir in util.GetRegionPinballDir():
phase_length = options.warmup_length // config.instr_cmpsim_phase
if phase_length == 0:
phase_length = 1
if not options.list:
msg.PrintMsgDate('Running Sniper on region pinballs %s' % \
config.PhaseStr(config.sniper_regions))
util.PhaseBegin(options)
result = RunSniper(pp_dir, sim_replay_cmd, phase_length,
options)
if not options.list:
msg.PrintMsgDate('Finished running Sniper on region pinballs %s' % \
config.PhaseStr(config.sniper_regions))
util.CheckResult(result, options, 'Sniper on region pinballs %s' % \
config.PhaseStr(config.sniper_regions))
if options.whole_sim or options.default_phases:
# Set phase_length to print out Sniper 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 Sniper on whole program pinballs %s' % \
config.PhaseStr(config.sniper_whole))
util.PhaseBegin(options)
result = RunSniper(wp_pb_dir, sim_replay_cmd, phase_length,
options)
if not options.list:
msg.PrintMsgDate('Finished running Sniper on whole program pinballs %s' % \
config.PhaseStr(config.sniper_whole))
util.CheckResult(result, options, 'Sniper on whole program pinballs %s' % \
config.PhaseStr(config.sniper_whole))
if options.pred_error or options.default_phases:
if options.pccount_regions:
msg.PrintMsg('\n Prediction with PCregions is NIY')
return 0
if not options.list:
msg.PrintMsgDate('Calculating prediction error %s' % \
config.PhaseStr(config.pred_error))
util.PhaseBegin(options)
result = CalcPredError(wp_pb_dir, self.sim_replay_cmd, 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))
# Assume nothing has gone wrong at this point.
#
return 0
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
def RunAdditionalPhases(self, wp_pb_dir, sim_replay_cmd, options):
"""
Run the additional phases for the simulator which are not run as
part of the usual PinPlay phases.
"""
phases_obj = phases.Phases()
self.sim_kit = self.GetSimKit()
# Run branch predictor simulator on region pinballs.
#
if options.region_sim or options.default_phases:
# Print out simulator results every warmup_length instructions.
#
for pp_dir in util.GetRegionPinballDir():
phase_length = options.warmup_length
if phase_length == 0:
phase_length = options.slice_size
if not options.list:
msg.PrintMsgDate('Running simulator on region pinballs: %s' % \
config.PhaseStr(config.sim_regions))
util.PhaseBegin(options)
result = self.sim_kit.RunSimulator(pp_dir, sim_replay_cmd,
phase_length, options)
if not options.list:
msg.PrintMsgDate('Finished running simulator on region pinballs: %s' % \
config.PhaseStr(config.sim_regions))
util.CheckResult(result, options, 'simulator on region pinballs: %s' % \
config.PhaseStr(config.sim_regions))
# Run branch predictor simulator on whole program pinballs.
#
if options.whole_sim or options.default_phases:
# Set phase_length to print out simulator results every slice_size instructions.
#
phase_length = options.slice_size
if not options.list:
msg.PrintMsgDate('Running simulator on whole program pinballs: %s' % \
config.PhaseStr(config.sim_whole))
util.PhaseBegin(options)
result = self.sim_kit.RunSimulator(wp_pb_dir, sim_replay_cmd,
phase_length, options)
if not options.list:
msg.PrintMsgDate('Finished running simulator on whole program pinballs: %s' % \
config.PhaseStr(config.sim_whole))
util.CheckResult(result, options, 'simulator on whole program pinballs: %s' % \
config.PhaseStr(config.sim_whole))
# Calculate prediction error.
#
if options.pred_error or options.default_phases:
if hasattr(options, 'pccount_regions') and options.pccount_regions:
msg.PrintMsg('\n Prediction with PCregions is NIY')
return 0
if not options.list:
msg.PrintMsgDate('Calculating prediction error: %s' % \
config.PhaseStr(config.pred_error))
util.PhaseBegin(options)
result = phases_obj.CalcPredError(wp_pb_dir, self.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))
# Assume nothing has gone wrong at this point.
#
return 0
