def ReplayAllFile(self, options): """Replays all pinballs based on a partial file name. @param options Options given on cmd line @return exit code from replaying all pinballs """ if config.debug: print('Replaying all pinballs matching patern.') import glob # If the user has given the "--all_file" option, then try to find all files # with this string. Replay all the pinballs in these directories. # result = 0 if options.all_file: param = {'options': options} for path in glob.glob('*' + options.all_file + '*'): pos = path.find(".address") if pos != -1: basename_file = path[0:pos] self.Replay(param, '', basename_file) # Wait until all the jobs complete. # if options.verbose: msg.PrintMsg( 'Calling WaitJobs() from replay_dir.py, ReplayAllFile()') result = util.WaitJobs(options) return result
def VerifyLITFiles(self, sim_run_cmd, options): """ Use a simulator to verify all the LIT files for the tracing instance are valid. """ # Verify the LIT files for each directory. # # import pdb; pdb.set_trace() result = 0 for lit_dir in util.GetLitDir(): if not options.list: msg.PrintMsgPlus('Verifying files in dir: ' + lit_dir) # import pdb; pdb.set_trace() cmd = sim_run_cmd + ' --replay_dir ' + lit_dir if options.sim_options: cmd += ' --sim_options ' + options.sim_options cmd += ' --verify' cmd += util.AddGlobalFile(self.gv.DumpGlobalVars(), options) cmd += util.AddCfgFile(options) result = util.RunCmd(cmd, options, '', concurrent=True) # Run jobs concurrently if result != 0: msg.PrintMsg('Error found during LIT file verification') return result # Wait for all the verification jobs to finish. # result = util.WaitJobs(options) return result
def ReplayOne(self, options): """ Replays one set of pinballs. Calls Replay() with the pinball name. @return exit code from replaying pinball """ param = {'options': options} self.Replay(param, '', options.replay_file) if options.verbose: msg.PrintMsg('Calling WaitJobs() from replay_dir.py, ReplayOne()') result = util.WaitJobs(options) return result
def Run(self): """ Get the user's options, read config file and execute the phases desired by the user. @return Exit code from last phase executed """ # Catch signals in order to do an orderly shutdown of the script. # self.InstallSigHandler() # import pdb; pdb.set_trace() options = 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 ProcessCommandLine(self, options): """ Replay pinballs using one of the 4 possible methods. 1) Replay one pinball 2) Replay all pinballs names whose name contains a string 3) Replay all pinballs in one directory 4) Replay all pinballs in the directories whose name contains a string @param options Options given on cmd line @return Exit code from replaying the last pinball """ # import pdb; pdb.set_trace() result = 0 if options.replay_file: result = self.ReplayOne(options) elif options.replay_dir: # Use util.RunAllDir() to execute the method Replay() on the # pinballs in the directory 'replay_dir'. Pass no_glob = True so # the directory name is NOT expanded. # param = {'options': options} if options.verbose: msg.PrintMsg( 'Calling util.RunAllDir() from replay_dir.py, ProcessCommandLine() replay_dir') result = util.RunAllDir(options.replay_dir, self.Replay, True, param) if result != 0: return result # Once all the jobs are started, then wait for them to finish # before we proceed. # if options.verbose: msg.PrintMsg( 'Calling WaitJobs() from replay_dir.py, ProcessCommandLine() replay_dir') result = util.WaitJobs(options) elif options.all_dir: # Use util.RunAllDir() to execute the method Replay() on the # pinballs in the directories which contain the string in # options.alldir. Pass no_glob = False so the directory name IS # expanded. # # import pdb; pdb.set_trace() param = {'options': options} if options.verbose: msg.PrintMsg( 'Calling util.RunAllDir() from replay_dir.py, ProcessCommandLine() all_dir') result = util.RunAllDir(options.all_dir, self.Replay, False, param) if result != 0: return result # Once all the jobs are started, then wait for them to finish # before we proceed. # if options.verbose: msg.PrintMsg( 'Calling WaitJobs() from replay_dir.py, ProcessCommandLine() all_dir') result = util.WaitJobs(options) elif options.all_file: result = self.ReplayAllFile(options) else: result = -1 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 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 RunSniper(pp_dir, sim_replay_cmd, phase_length, options): def round(x, roundby=1000000): return int(int((x / float(roundby))) * float(roundby)) # List of pinballs used to print Sniper output when all runs are complete. # pb_list = [] ret = 0 if not os.path.isdir(pp_dir): # If running in MPI_MT_MODE, then it's possible for one process to not # have a thread corresponding to the the current focus thread. # However, another process might have this thread. Thus, only return # an error if not tracing a MPI_MT application. # if options.mode == config.MPI_MT_MODE: msg.PrintMsg('WARNING: Directory containing pinballs to run with simulator does not exist:\n ' + \ pp_dir) msg.PrintMsg('Since tracing mode is \'mpi_mt\', this may be OK.') return 0 else: msg.PrintMsg('ERROR: Directory containing pinballs to run with simulator does not exist:\n ' + \ pp_dir) return -1 # List of output sniper directories. # output_dir_list = [] for fn in os.listdir(pp_dir): if fn.endswith('.address'): pinball_path = os.path.join(pp_dir, os.path.splitext(fn)[0]) fn = os.path.splitext(fn)[0] sniper_outputdir = os.path.join(config.sniper_result_dir, pinball_path) output_dir_list += [sniper_outputdir] sniper_outputfile = pinball_path + config.sniper_out_ext if options.debug: # If debugging, check to see if the Sniper result files already exist for the pinball. If so, # then print it out but don't run Sniper again. # if os.path.isdir(sniper_outputdir): msg.PrintMsgPlus( 'WARNING: Skipping Sniper execution because output file already exists.\n' ' %s' % sniper_outputdir) pb_list.append(pinball_path) continue # Select the proper config/options to run the desired version of # Sniper/SniperLite. # # import pdb; pdb.set_trace() if options.sniper_options: common_sniper_opts = options.sniper_options else: if options.no_sniperlite: common_sniper_opts = '' else: # use_orig = True # Use older SniperLite options use_orig = False # New SniperLite options if use_orig: common_sniper_opts = ' -c dunnington -c cacheonly -c nehalem_cmpsim.cfg ' \ '-g --general/enable_icache_modeling=false ' \ '-g --perf_model/dram/direct_access=true ' \ '-g --perf_model/dram/queue_model/type=contention ' \ '-g --perf_model/dtlb/size=0' else: # Older patched Sniper 5.3 # # common_sniper_opts = ' -c dunnington -c nehalem_cmpsim.cfg -c ccpp1c --pinball-non-sift \ # -g -replay:addr_trans -g --general/enable_icache_modeling=false' # Newer patched Sniper 5.3 # # common_sniper_opts = ' -c dunnington -c nehalem_cmpsim.cfg -c cc-fast --pinball-non-sift \ # -g -replay:addr_trans -g --general/enable_icache_modeling=false' # Production SniperLite 6.0 options # common_sniper_opts = ' -c nehalem-lite --pinball-non-sift ' partial_run_cmd = (common_sniper_opts + ' --no-cache-warming') try: # If re.search() fails, code falls though to the exception. # warmup_region = re.search('warmup(\d+)_prolog(\d+)_region(\d+)_epilog(\d+)_(\d+)_(\d-\d+)', \ pinball_path) # Get info on the length of regions in the pinball. # warmup = int(warmup_region.group(1)) prolog = int(warmup_region.group(2)) file_region = int(warmup_region.group(3)) epilog = int(warmup_region.group(4)) region_num = int(warmup_region.group(5)) weight = warmup_region.group(6).replace('-', '.') icount = util.GetMaxIcount('', pinball_path) sim_region_len = icount - warmup calc_region = sim_region_len - prolog - epilog if warmup != 0: # If there are warmups, then need to use options to first do cache warmups in Sniper, # then simulate the region. # partial_run_cmd = (common_sniper_opts + ' -s stop-by-icount:%d:%d ' \ % (sim_region_len, round(warmup)) + ' --roi-script ') if not options.list: # Print details about the various sections in the pinball. # msg.PrintMsgPlus('Running Sniper on: ' + fn) msg.PrintMsg(' Warmup count: ' + locale.format('%14d', warmup, True)) msg.PrintMsg(' Prolog count: ' + locale.format('%14d', prolog, True)) msg.PrintMsg(' Actual region count: ' + locale.format('%14d', calc_region, True) + \ ' (from file name: ' + locale.format('%d', file_region, True) + ')') msg.PrintMsg(' Epilog count: ' + locale.format('%14d', epilog, True)) msg.PrintMsg(' Total Instr count: ' + locale.format('%14d', icount, True)) except AttributeError: if 'whole_program' not in pinball_path: # Whole program pinballs cannot be processed using the options # given above (using -s stop-by-icount:) because they don't have # warmup instructions to be skipped. # # Let the user know the results may be suspect because the dir # appears to contain whole program pinballs, but the name doesn't # contain the string 'whole_program'. However, don't flag this as # an erorr. It's possible for the user to give the name of a WP # pinball directory which does not contain this string. # msg.PrintMsgPlus( 'WARNING: This pinball may not really be a whole program pinball.\n' ' If this is true, the results may not be valid.\n' ' ' + pinball_path) msg.PrintMsgPlus('Running Sniper on whole program pinball: ' + pinball_path) # Format the command and execute it asynchronously. # cmd = os.path.join(options.sniper_root, sim_replay_cmd) + partial_run_cmd + \ (' -d "%s" ' % sniper_outputdir) + ' --pinballs ' + pinball_path + \ ' > ' + sniper_outputfile + ' 2>&1 ' pb_list.append(pinball_path) end_str = fn # import pdb; pdb.set_trace() result = util.RunCmd(cmd, options, end_str, concurrent=True) ret = result or ret result = util.WaitJobs(options) ret = result or ret # Make sure some of the important Sniper output files exist for each pinball. # file_list = ['sim.stats.sqlite3', 'sim.info', 'sim.cfg', 'sim.out'] for sim_dir in output_dir_list: for f in file_list: if not os.path.isfile(os.path.join(sim_dir, f)): msg.PrintMsg('\nERROR: Sniper output file does not exist:\n' \ ' ' + os.path.join(sim_dir, f)) ret = -1 # Define a set of strings which can be ignored as errors if they occur in # the output. These are special cases which must be added by hand when a # new application is found that contains a string which might be detected # as an erorr, but is a normal component of the output from running the # application. # Errors generated by Sniper itself which are acceptable. # ign_str = [ 'void Sift::Writer::Sync(): Assertion', 'Sift::Reader::decodeInstruction' ] pin_app_term = 'Pin app terminated abnormally' ign_str += [pin_app_term] # Strings generated by SPEC CPU2006 benchmarks: dealII-ref-1 # ign_str += ['Estimated error='] # Strings generated by MILC # ign_str += ['error_per_site', 'No O(a^2) errors', 'error_for_propagator'] # Print the output from running Sniper and look for errors in the output. # error = False for pinball_path in pb_list: # Get just the pinball name & print it # fn = os.path.split(pinball_path)[1] sniper_outputfile = pinball_path + config.sniper_out_ext if os.path.isfile(sniper_outputfile): try: f_stdout = open(sniper_outputfile, 'r') except IOError: msg.PrintMsg( 'ERROR: Can\'t open Sniper output file to look for errors.\n' ' ' + sniper_outputfile) ret = -1 # Print the output file and look for errors. # if not options.list: if 'whole_program' in pinball_path: msg.PrintMsg('\nSniper output for: ' + pinball_path) else: msg.PrintMsg('\nSniper output for: ' + fn) for line in f_stdout.readlines(): msg.PrintMsgNoCR(line) if not options.ignore_sniper_error and \ ('ERROR' in line or \ 'error' in line or \ 'Traceback' in line): # Check to see if we can accept this line because # it contains one of the strings we can ignore. # ok_ignore = False for st in ign_str: if st in line: ok_ignore = True break if not ok_ignore: # It's truly an error # error = True # Need to print a msg indicating this error is OK to ignore. # if pin_app_term in line: msg.PrintMsg( 'The \'Pin app terminated\' msg can be ignored. ' 'It is not an error, just a warning.') if error: msg.PrintMsg('\nERROR: Sniper failed with an error.') ret = -1 error = False # Reset in order to look for error in next pb return ret
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