def ParseCommandLine(self):
"""
Process command line arguments and read in config file/globals.
@return List of options parsed from command line
"""
version = '$Revision: 1.100 $'
version = version.replace(' ', '')
ver = version.replace(' $', '')
us = '%prog phase [options] \nVersion: ' + ver
desc = 'The script generates traces for an application using the PinPoints methodology '\
'(based on PinPlay: Pin-based record/replay tools). '\
'At least one command line option must be given to chose the phases to run. ' \
'Use option \'--default_phases\' to run all the default phases. ' \
'See section "Phase options" for a list of phases. \n\n'\
'' \
'The two parameters \'program_name\' and \'input_name\' must be defined in order '\
'to run this script. If running the logging phase (-l), then two more parameters, '\
'\'command\' and \'mode\', must also be defined. '\
'Parameters can be given either in a tracing configuration file or with command '\
'line options. \n\n'\
'' \
'The default configuration file is "tracing.cfg". '\
'If it exists, the script will always read this cfg file first. '\
'Use the option "--cfg" to select additional files. '\
'Each cfg file on the command line is processed in order. '\
'Command line options over-ride values read from configuration files. '\
'All parameters listed in the three parameter '\
'sections below can be defined in a cfg file. The long option name, '\
'not the single letter option, must be used in the cfg files.\n\n'\
'' \
'Example parameter configuration file:'\
' '\
'--------------------------------------------'\
' '\
'[Parameters]'\
' '\
'program_name: omnetpp'\
' '\
'input_name: p10000-s10'\
' '\
'command: ./dtlb5-lin64 -p10000 -s10'\
' '\
'mode: st'\
' '\
'--------------------------------------------'
util.CheckNonPrintChar(sys.argv)
parser = optparse.OptionParser(
usage=us,
description=desc,
version=ver,
formatter=cmd_options.BlankLinesIndentedHelpFormatter())
# Command line options to control the tools behavior. These are not in any
# of the option groups.
#
# import pdb; pdb.set_trace()
cmd_options.add_program_wp(parser)
cmd_options.append_status(parser)
cmd_options.config_file(parser)
cmd_options.debug(parser)
cmd_options.delete(parser)
cmd_options.delete_all(parser)
cmd_options.delete_wp(parser)
cmd_options.dir_separator(parser)
cmd_options.log_options(parser)
cmd_options.msgfile_ext(parser)
cmd_options.no_glob(parser)
cmd_options.pintool(parser)
cmd_options.pin_options(parser)
cmd_options.replay_options(parser)
cmd_options.save_global(parser)
cmd_options.verbose(parser)
self.AddAdditionalOptions(parser)
# Top level command line options in the default group allow the user
# to choose the phases to run.
#
phase_group = cmd_options.PhaseGroup(parser)
cmd_options.default_phases(parser, phase_group)
cmd_options.native_pure(parser, phase_group)
cmd_options.log(parser, phase_group)
cmd_options.replay(parser, phase_group)
cmd_options.basic_block_vector(parser, phase_group)
cmd_options.simpoint(parser, phase_group)
cmd_options.region_pinball(parser, phase_group)
cmd_options.replay_region(parser, phase_group)
self.AddAdditionalPhaseOptions(parser, phase_group)
parser.add_option_group(phase_group)
# Top level command line options in param group are used to set various
# tracing parameters.
#
param_group = cmd_options.ParameterGroup(parser)
cmd_options.command(parser, param_group)
cmd_options.compressed(parser, param_group)
cmd_options.focus_thread(parser, param_group)
cmd_options.input_name(parser, param_group)
cmd_options.mpi_options(parser, param_group)
cmd_options.mode(parser, param_group)
cmd_options.num_cores(parser, param_group)
cmd_options.num_proc(parser, param_group)
cmd_options.program_name(parser, param_group)
self.KitOption(parser, param_group)
parser.add_option_group(param_group)
# Top level command line options which only apply to the Simpoint phase.
#
simpoint_phase_group = cmd_options.SimpointPhaseGroup(parser)
cmd_options.combine(parser, simpoint_phase_group)
cmd_options.cutoff(parser, simpoint_phase_group)
cmd_options.ldv(parser, simpoint_phase_group)
cmd_options.maxk(parser, simpoint_phase_group)
cmd_options.slice_size(parser, simpoint_phase_group)
cmd_options.warmup_factor(parser, simpoint_phase_group)
cmd_options.pccount_regions(parser, simpoint_phase_group)
cmd_options.global_regions(parser, simpoint_phase_group)
cmd_options.simpoint_options(parser, simpoint_phase_group)
parser.add_option_group(simpoint_phase_group)
# Top level command line options which only apply to the region pinball generation phase.
#
region_pb_phase_group = cmd_options.RegionPBPhaseGroup(parser)
cmd_options.epilog_length(parser, region_pb_phase_group)
cmd_options.prolog_length(parser, region_pb_phase_group)
cmd_options.warmup_length(parser, region_pb_phase_group)
parser.add_option_group(region_pb_phase_group)
# Add verify options.
#
self.AddVerifyOptions(parser)
# Top level command line options in modify group modify the behavior of phases.
#
modify_group = cmd_options.ModifyGroup(parser)
# These should go before the rest of the modify options.
#
cmd_options.coop_pinball(parser, modify_group)
cmd_options.cross_os(parser, modify_group)
cmd_options.list(parser, modify_group)
cmd_options.native_pin(parser, modify_group)
cmd_options.no_focus_thread(parser, modify_group)
cmd_options.whole_pgm_dir(parser, modify_group)
self.AddAdditionalModifyOptions(parser, modify_group)
parser.add_option_group(modify_group)
# Top level command line options in which only apply to the region pinball generation phase.
#
wp_filter_group = cmd_options.WPFilterGroup(parser)
cmd_options.relog_name(parser, wp_filter_group)
cmd_options.relog_focus(parser, wp_filter_group)
cmd_options.relog_no_init(parser, wp_filter_group)
cmd_options.relog_no_cleanup(parser, wp_filter_group)
cmd_options.relog_code_exclude(parser, wp_filter_group)
cmd_options.relog_no_omp_spin(parser, wp_filter_group)
cmd_options.relog_no_mpi_spin(parser, wp_filter_group)
cmd_options.use_relog_name(parser, wp_filter_group)
cmd_options.use_relog_focus(parser, wp_filter_group)
cmd_options.use_relog_no_cleanup(parser, wp_filter_group)
cmd_options.use_relog_no_init(parser, wp_filter_group)
cmd_options.use_relog_code_exclude(parser, wp_filter_group)
cmd_options.use_relog_no_omp_spin(parser, wp_filter_group)
cmd_options.use_relog_no_mpi_spin(parser, wp_filter_group)
parser.add_option_group(wp_filter_group)
# Parse the command line options.
#
# import pdb; pdb.set_trace()
(options, args) = parser.parse_args()
# Added method cbsp() to 'options' to check if running CBSP.
#
util.AddMethodcbsp(options)
# Check to make sure there was at least one command line option given.
#
# import pdb; pdb.set_trace()
if len(sys.argv) == 1:
msg.PrintMsg(
"ERROR: Must use command line options to chose at least one phase to run.\n"
"Use the option '--default_phases' to run the default phases. Use '--help' for more info.")
util.CheckResult(-1, options, 'Checking command line options')
# If user does not just want to delete all the files, then
# read in configuration files and set global variables.
#
# import pdb; pdb.set_trace()
if not options.delete_all:
self.Config.GetCfgGlobals(options,
True) # Yes, need 4 required parameters
# Once the tracing configuration parameters are read, get the kit
# in case pinplayhome was set on the command line. Also, need to
# reset the path in object 'self' and set the kit in self.phases.
#
# import pdb; pdb.set_trace()
kit_obj = self.GetKit()
self.path = kit_obj.path
self.script_path = kit_obj.path
self.phases.SetKit(kit_obj)
# If required, check to see if there any 'forbidden' char in some of
# the parameters.
#
# import pdb; pdb.set_trace()
if self.kit_type == config.SDE and hasattr(options,
'spec') and not options.spec:
self.Config.CheckForbiddenChar()
# If doing code exclusion, check to make sure the file exists.
#
if options.relog_code_exclude:
if not os.path.exists(options.relog_code_exclude):
msg.PrintMsg(
'ERROR: The code exclusion file used for filtering does not exist:\n'
' ' + options.relog_code_exclude)
util.CheckResult(-1, options, 'Checking command line options')
# Do some 'special' things on native Windows.
#
util.WindowsNativeCheck(options)
return options
def ParseCommandLine(self):
"""
Process command line arguments, get Kit, tool options, and their paths.
@return List containing: pin_options, pintool_options, options.replay_file, kit_obj
"""
# import pdb; pdb.set_trace()
version = '$Revision: 1.63 $'
version = version.replace(' ', '')
ver = version.replace(' $', '')
us = '%prog [options] pinball_basename \nVersion: ' + ver
desc = 'Replays one pinball. Use \'--replay_options\' or ' \
'\'--log_options\' to modify the pintool behavior during replay.'
util.CheckNonPrintChar(sys.argv)
parser = optparse.OptionParser(usage=us, version=ver, description=desc)
# Define the command line options which control the behavior of the
# script.
#
# Some of these methods take a 2nd argument which is the empty string
# ''. If this script used option groups, then the 2nd parameter would
# be the group. However, this script does not use option groups, so
# the argument is empty.
#
cmd_options.arch(parser, '')
cmd_options.config_file(parser)
cmd_options.cross_os(parser, '')
cmd_options.debug(parser)
cmd_options.global_file(parser)
cmd_options.log_options(parser)
cmd_options.msgfile_ext(parser)
cmd_options.no_print_cmd(parser)
cmd_options.pintool(parser)
cmd_options.pintool_help(parser)
cmd_options.pin_options(parser)
cmd_options.pinplayhome(parser, '')
cmd_options.playout(parser)
cmd_options.replay_file(parser)
cmd_options.replay_options(parser)
cmd_options.save_global(parser)
cmd_options.sdehome(parser, '')
cmd_options.verbose(parser)
# import pdb; pdb.set_trace()
(options, args) = parser.parse_args()
if options.verbose:
msg.PrintMsg('Started replayer.py')
# Check to make sure the pinball basename has been given as an argument or
# command line option.
#
# import pdb; pdb.set_trace()
if options.replay_file == '' and \
not (hasattr(options, 'pintool_help') and options.pintool_help):
if len(sys.argv) == 1 or len(args) == 0:
msg.PrintMsg(
"ERROR: Must have a trace basename on the command line.\n"
"Usage: %s [options] pinball_basename" %
os.path.basename(sys.argv[0]))
util.CheckResult(-1, options, 'Checking command line options')
options.replay_file = args[0]
# Read in an optional configuration files and set global variables.
#
config_obj = config.ConfigClass()
config_obj.GetCfgGlobals(options,
False) # Don't need to require 4 variables
# Once the tracing configuration parameters are read, get the kit in
# case pinplayhome was set on the command line.
#
# import pdb; pdb.set_trace()
kit_obj = self.GetKit()
# If user just wants 'pintool_help' go ahead and print it, then exit
# the script.
#
if hasattr(options, 'pintool_help') and options.pintool_help:
result = util.PintoolHelpKit(kit_obj, options)
sys.exit(result)
# Translate the 'arch' value given by the user into
# the internal arch type used by the scripts.
#
if hasattr(options, 'arch') and options.arch:
if 'intel64' in options.arch:
options.arch = config.ARCH_INTEL64
elif 'ia32' in options.arch:
options.arch = config.ARCH_IA32
else:
options.arch = config.ARCH_INVALID
# Now that we know the type of the binary, set the user defined pintool,
# if one exists. Need to wait until now to set the tool because the
# user may only have the tool in the architecture dependent directory
# for this type of application. Thus we need the binary type in order
# to find it.
#
# import pdb; pdb.set_trace()
kit_obj.binary_type = options.arch
pin_options = ''
pintool_options = ''
# Check to see if there is a pinball to replay.
#
if options.replay_file == "":
msg.PrintHelpAndExit('Replay file not specified!')
# If the user specified a pintool, replace the default pintool in the kit with
# it.
#
if hasattr(options, "pintool") and options.pintool:
kit_obj.SetPinTool(options.pintool, options.replay_file)
platform = util.Platform()
if platform == config.LINUX:
pin_options = ' ' + kit_obj.prefix + ' -xyzzy '
# If using NOT using Linux tools to work with whole program pinballs generated on Windows,
# then need a set of knobs for the pin binary itself.
#
if not options.cross_os:
pin_options += kit_obj.prefix + ' -reserve_memory '
pin_options += kit_obj.prefix + ' ' + options.replay_file + '.address '
pintool_options += ' -replay:basename ' + options.replay_file
if options.playout or '-replay:playout 1' in options.replay_options:
# If present, need to remove the knob '-replay:playout 1' from
# options.replay_options because it can only be given once on the
# command line.
#
pintool_options += ' -replay:playout 1 '
options.replay_options = options.replay_options.replace(
'-replay:playout 1', '')
else:
pintool_options += ' -replay:playout 0 '
# If running Windows WP pinballs on Linux, then need this knob for the replayer pintool.
#
if options.cross_os:
pintool_options += ' -replay:addr_trans'
# Add knobs for Pin and replay/logging user gave on the command line.
#
pin_options += ' ' + options.pin_options
pintool_options += ' ' + options.replay_options + ' ' + options.log_options
# If user has log options, then may need to at multi-thread knob.
#
if options.log_options:
pintool_options += util.AddMt(options, options.replay_file)
return pin_options, pintool_options, options.replay_file, kit_obj, options
def ParseCommandLine(self):
"""
Parse command line arguments and check to make sure all required options were given.
@return List of options
"""
# command line options for the driver
#
version = '$Revision: 1.14 $'
version = version.replace(' ', '')
ver = version.replace(' $', '')
us = '%prog [options] --mode MODE binary args'
desc = 'Runs binary with the logger Pintool and generates whole program '\
'pinballs. Required arguments include:\n'\
' 1) Binary to run and it\'s arguments.\n'\
' 2) Mode of the binary using \'--mode MODE\'.\n'\
'If the option \'--log_file\' is not given, the default pinball name is \'log\'.'
util.CheckNonPrintChar(sys.argv)
parser = optparse.OptionParser(
usage=us,
version=ver,
description=desc,
formatter=cmd_options.BlankLinesIndentedHelpFormatter())
# Define the command line options which control the behavior of the
# script. Some of these methods take a 2nd argument which is the empty
# string ''. If the script uses option groups, then this parameter is
# the group. However, this script does not use option groups, so the
# argument is empty.
#
cmd_options.arch(parser, '')
cmd_options.compressed(parser, '')
cmd_options.config_file(parser)
cmd_options.debug(parser)
cmd_options.global_file(parser)
cmd_options.log_file(parser)
cmd_options.log_options(parser)
cmd_options.mode(parser, '')
cmd_options.mpi_options(parser, '')
cmd_options.msgfile_ext(parser)
cmd_options.no_log(parser)
cmd_options.no_print_cmd(parser)
cmd_options.pid(parser)
cmd_options.pinplayhome(parser, '')
cmd_options.pintool(parser)
cmd_options.pintool_help(parser)
cmd_options.pin_options(parser)
cmd_options.save_global(parser)
cmd_options.sdehome(parser, '')
cmd_options.verbose(parser)
# import pdb; pdb.set_trace()
(options, args) = parser.parse_args()
# Added method cbsp() to 'options' to check if running CBSP.
#
util.AddMethodcbsp(options)
# Translate the 'arch' string given by the user into
# the internal arch type used by the scripts.
#
util.SetArch(options)
# If user just wants pintool_help, return
#
if (hasattr(options, 'pintool_help') and options.pintool_help):
return options
# Read in configuration files and set global variables.
# No requirment to read in a config file, but it's OK
# to give one.
#
config_obj = config.ConfigClass()
config_obj.GetCfgGlobals(options,
False) # No, don't need required parameters
# Make sure user gave an application mode
#
if options.mode:
options.mode = util.ParseMode(options.mode)
else:
parser.error("Application mode was not given.\n" \
"Need to use option --mode MODE. Choose MODE from: 'st', 'mt', 'mpi', 'mpi_mt', 'mp', 'mp_mt'")
# Get the application command line
#
# import pdb; pdb.set_trace()
cmd_line = " ".join(args)
if not options.pid:
if cmd_line:
setattr(options, 'command', cmd_line)
else:
parser.error('no program command line specified.\n'
'Need to add binary and it\'s arguments.')
return options
def ParseCommandLine(self):
"""
Parse command line arguments and returns pin and tools options and app command line.
@return List containing: options
"""
# command line options for the driver
#
version = '$Revision: 1.81 $'
version = version.replace('$Revision: ', '')
ver = version.replace(' $', '')
us = '%prog [options] --mode MODE --log_file FILE binary args'
desc = 'Runs binary with the logger Pintool and generates whole program '\
'pinballs. Required arguments include:\n'\
' 1) Binary to run and it\'s arguments.\n'\
' 2) Name for the log file (pinball) using \'--log_file FILE\'\n'\
' Name can include a dir as well as a file.\n' \
' 3) Mode of the binary using \'--mode MODE\'.'
util.CheckNonPrintChar(sys.argv)
parser = optparse.OptionParser(
usage=us,
description=desc,
version=ver,
formatter=cmd_options.BlankLinesIndentedHelpFormatter())
# Define the command line options which control the behavior of the
# script. Some of these methods take a 2nd argument which is the empty
# string ''. If the script uses option groups, then this parameter is
# the group. However, this script does not use option groups, so the
# argument is empty.
#
cmd_options.compressed(parser, '')
cmd_options.config_file(parser)
cmd_options.debug(parser)
cmd_options.global_file(parser)
cmd_options.list(parser, '')
cmd_options.log_file(parser)
cmd_options.log_options(parser)
cmd_options.mode(parser, '')
cmd_options.mpi_options(parser, '')
cmd_options.msgfile_ext(parser)
cmd_options.no_log(parser)
cmd_options.num_proc(parser, '')
cmd_options.pid(parser)
cmd_options.pinplayhome(parser, '')
cmd_options.pintool(parser)
cmd_options.pin_options(parser)
cmd_options.save_global(parser)
cmd_options.sdehome(parser, '')
cmd_options.verbose(parser)
# import pdb; pdb.set_trace()
(options, args) = parser.parse_args()
# Read in configuration files and set global variables.
# No need to read in a config file.
#
config_obj = config.ConfigClass()
config_obj.GetCfgGlobals(options,
False) # No, don't need required parameters
# Make sure user gave an application mode
#
if options.mode:
options.mode = util.ParseMode(options.mode)
else:
parser.error(
"Application mode was not given.\n"
"Need to use option --mode MODE. Choose MODE from: 'st', 'mt', 'mpi', 'mpi_mt', 'mp', 'mp_mt',"
)
# Log file name must be given.
#
# import pdb; pdb.set_trace()
if options.log_file == '':
parser.error('Log file basename was not given.\n' \
'Must give basename with option: --log_file FILE')
# Get the application command line
#
# import pdb; pdb.set_trace()
cmd_line = " ".join(args)
if not options.pid:
if cmd_line:
setattr(options, 'command', cmd_line)
else:
parser.error('no program command line specified.\n'
'Need to add binary and it\'s arguments.')
return options
