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