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 GetOptions():
"""Get users command line options."""
version = '$Revision: 1.20 $'
version = version.replace(' ', '')
ver = version.replace(' $', '')
us = '%prog [options] app_version compiler_version input_name platform program_name'
desc = \
'Renames tracing files generated by PinPlay tools to conform to the GTR requirements. ' \
'There are 5 arguments required to run the script. Details are given below in the ' \
'section \'Required arguments\'.'
# Print arguments passed to the script.
#
# import pdb; pdb.set_trace()
msg.PrintMsgNoCR('Script args: '),
for string in sys.argv[1:]:
msg.PrintMsgNoCR(string + ' '),
msg.PrintMsg('')
msg.PrintMsg('')
util.CheckNonPrintChar(sys.argv)
parser = optparse.OptionParser(
usage=us,
version=ver,
description=desc,
formatter=cmd_options.BlankLinesIndentedHelpFormatter())
# Command line options to control the scripts behavior.
#
# import pdb; pdb.set_trace()
cmd_options.config_file(parser)
cmd_options.debug(parser)
cmd_options.date(parser, '')
cmd_options.processor(parser, '')
cmd_options.verbose(parser)
# Define a separate option group for the require arguments.
#
required_opts = cmd_options.RenameRequiredOpts(parser)
cmd_options.app_version(parser, required_opts)
cmd_options.compiler_version(parser, required_opts)
cmd_options.input_name(parser, required_opts)
cmd_options.platform(parser, required_opts)
cmd_options.program_name(parser, required_opts)
parser.add_option_group(required_opts)
(options, args) = parser.parse_args()
# Read in the configuration file.
#
Config.GetCfgGlobals(options, True) # 2 required parameters are needed
# Ensure the required variables are defined.
#
CheckRequiredVariables(options)
# If the user didn't give a date, use the current date.
#
if options.date == '':
today = datetime.date.today()
options.date = today.strftime('%y%m')
CheckField(options.date)
# If user didn't give a separate processor name, get it from the platform info.
#
if options.processor == '':
# Use the first 3 char as the processor type
options.processor = options.platform[:3]
CheckField(options.processor)
return options
def ParseCommandLine(self):
"""
Process command line arguments and read in config file/globals.
@return List of options parsed from command line
"""
version = '$Revision: 1.11 $'
version = version.replace(' ', '')
ver = version.replace(' $', '')
us = '%prog <phase> --cbsp_cfgs CFG_FILE,CFG_FILE[,CFG_FILE] [options] '
desc = 'This script uses Cross Binary SimPoint (CBSP) and PinPlay tools ' \
'to create a set of equal-work traces from two, or more, binaries compiled from the same source.\n\n'\
'' \
'At least one command line option must be given to chose the phase(s) of the script to run. ' \
'Use option \'--default_phases\' to run all phases. ' \
'See section "Phase options" for a list of phases. \n\n'\
'' \
'The option \'--cbsp_cfgs\' is also required to run this scripts. It contains a list of PinPlay configuration '\
'files. Each file defines one of the binaries to be traced. (See \'sde_pinpoints.py -h\' for more info on PinPlay config files.)\n\n'\
'' \
'Optional master CBSP config files may be given with the option \'-cfg\'. The parameters '\
'defined in each master cfg file are used for every binary. Master CBSP config files are not required.\n\n'\
'' \
'Master CBSP cfg files are processed in order. '\
'Command line options over-ride values read from master CBSP configuration files. '\
'The long option name, '\
'not the single letter option, must be used in the config files.\n\n'\
'' \
'The parameter \'cbsp_name\' MUST be defined in at least one configuration file in order '\
'to run this script. It may be defined in master/binary CBSP config files or by command line option.\n\n'\
'' \
'Example configuration file:'\
' '\
'--------------------------------------------'\
' '\
'[Parameters]'\
' '\
'cbsp_name: lipack_test'\
' '\
'program_name: linpack'\
' '\
'input_name: avx'\
' '\
'command: AVX_linpack 8'\
' '\
'mode: st'\
' '\
'--------------------------------------------\n\n'\
'' \
'Advanced Usage: Since CBSP is an extension of PinPlay, it\'s possible to combine the two '\
'tool chains to generate traces. For example, you can use sde_pinplay.py to generate whole program '\
'pinballs in parallel (possibly using NetBatch). Then use the CBSP script to run the \'cb_match\' '\
'and \'simpoint\' phases to select equivalent work clusters in each binary. Finally, you can run '\
'sde_pinpoints.py with NetBatch to generate region pinballs/LIT files in parallel.\n\n'\
'' \
'If using this method, you must use the configuration file for just one binary with each invocation of '\
'the sde_pinpoints.py script. Also, in order to combine these tools, you must add the option '\
'\'--add_program_wp\' to each sde_pinpoints.py run. This is required so the directories names '\
'generated/used by the two chains are compatible. '\
''
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.cbsp_cfgs(parser)
cmd_options.config_file(parser)
cmd_options.debug(parser)
cmd_options.delete(parser)
cmd_options.delete_all(parser)
# cmd_options.dir_separator(parser) # Only works for PinPlay, need to fix for CBSP
cmd_options.log_options(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)
self.default_phases(parser, phase_group)
cmd_options.log(parser, phase_group)
cmd_options.cb_match(parser, phase_group)
cmd_options.simpoint(parser, phase_group)
cmd_options.region_pinball(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.cbsp_name(parser, param_group)
cmd_options.input_name(parser, param_group)
cmd_options.num_cores(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.maxk(parser, simpoint_phase_group)
cmd_options.simpoint_options(parser, simpoint_phase_group)
cmd_options.slice_size(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)
# 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)
parser.add_option_group(modify_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(
"\nERROR: 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,
'Check command line options - no phase given')
# User must give option/parameter 'cbsp_cfgs' (unless deleting files).
#
# import pdb; pdb.set_trace()
if not options.delete_all and \
(not hasattr(options, 'cbsp_cfgs') or not options.cbsp_cfgs):
msg.PrintMsg(
'\nERROR: Must give list of configuration files for the CBSP binaries\n'
'using parameter \'--cbsp_cfgs\'.')
util.CheckResult(-1, options, 'Check command line options - '
'Looking for parameter \'cbsp_cfgs\'.')
# Get a list of the parameters for each CBSP binary.
#
# import pdb; pdb.set_trace()
bin_options = self.Config.GetAllCBSPBinParams(options)
# Added method cbsp() to 'options' to check if running CBSP.
#
util.AddMethodcbsp(options)
# Now that we have all the parameters, create a new status file or,
# zero out the file if it already exists. Need all the parameters
# because 'cbsp_name' is used as part of the status file name. If user
# sets parameter 'append_status', the old file is not deleted.
#
util.NewStatusFile(options, cbsp=True)
# Ensure each binary has a unique program_name/input_name
#
all_names = set()
for bopts in bin_options:
name = '%s %s' % (bopts.program_name, bopts.input_name)
if name in all_names:
msg.PrintMsg(
'\nERROR: Must have unique program_name & input_name for '
'each binary.\n'
'Found duplicates: %s' % name)
util.CheckResult(-1, options, 'Check command line options - '
'Found duplicate program_name & input_name')
all_names.add(name)
# For debugging, print out the WP directory names for each binary
#
if hasattr(options, 'verbose') and options.verbose:
for bopts in bin_options:
msg.PrintMsg('WP dir: ' + util.GetDefaultWPDir(bopts))
# Once the tracing configuration parameters are read, get the kit in
# case sdehome/pinplayhome was set on the command line or in a config
# file. Also, need to reset paths to kit/scripts in object 'self' and
# set the kit in self.phases.
#
kit_obj = self.GetKit()
self.path = kit_obj.path
self.script_path = kit_obj.script_path
self.phases.SetKit(kit_obj)
# If required, check to see if there any 'forbidden' char in some of
# the parameters.
#
if self.kit_type == config.SDE and hasattr(options,
'spec') and not options.spec:
self.Config.CheckForbiddenChar()
# Do some 'special' things on native Windows.
#
util.WindowsNativeCheck(options)
return options, bin_options