def execute(argv): """Generate random sequences for each benchmark""" del argv FLAGS = flags.FLAGS # The benchmarks benchmarks = IO.load_yaml_or_fail(FLAGS.benchmarks_filename) if not benchmarks: logging.error('There are no benchmarks to process') sys.exit(1) # Verify benchmark directory if not os.path.isdir(FLAGS.benchmarks_directory): logging.error('Benchmarks directory {} does not exist.'.format( FLAGS.benchmarks_directory)) sys.exit(1) # Create the results directory try: os.makedirs(FLAGS.results_directory) except FileExistsError: pass # Process each benchmark for benchmark in tqdm(benchmarks, desc='Processing'): index = benchmark.find('.') suite_name = benchmark[:index] bench_name = benchmark[index + 1:] benchmark_dir = os.path.join(FLAGS.benchmarks_directory, suite_name, bench_name) if not os.path.isdir(benchmark_dir): continue results_dir = os.path.join(FLAGS.results_directory, suite_name) # Create the results directory for the suite try: os.makedirs(results_dir) except FileExistsError: pass filename = '{}/{}.yaml'.format(results_dir, bench_name) if FLAGS.verify_report and os.path.isfile(filename): continue Engine.compilee(benchmark_dir, 'opt', '-{}'.format(FLAGS.baseline)) features = Milepost.extract(benchmark_dir) # Engine.cleanup(benchmark_dir, 'opt') IO.dump_yaml(features, filename)
def execute(argv): """Generate random sequences for each benchmark""" del argv FLAGS = flags.FLAGS # The benchmarks benchmarks = IO.load_yaml(FLAGS.benchmarks_filename) if not benchmarks: logging.fatal('There are no benchmarks to process') # Create the results directory try: os.makedirs(FLAGS.results_directory) except FileExistsError: pass # Process each benchmark for benchmark in tqdm(benchmarks, desc='Processing'): index = benchmark.find('.') bench_dir = benchmark[:index] bench_name = benchmark[index + 1:] bench_in_dir = os.path.join(FLAGS.benchmarks_directory, bench_dir, bench_name) if not os.path.isdir(bench_in_dir): continue bench_out_dir = os.path.join(FLAGS.results_directory, bench_dir) # Create the results directory for the suite try: os.makedirs(bench_out_dir) except FileExistsError: pass filename = '{}/{}.yaml'.format(bench_out_dir, bench_name) if FLAGS.verify_report and os.path.isfile(filename): continue results = {} for compiler in ['opt', 'llvm']: for level in FLAGS.levels: goal_value = Engine.evaluate( Goals.prepare_goals(FLAGS.goals, FLAGS.weights), '-{}'.format(level), compiler, bench_in_dir, FLAGS.working_set, FLAGS.times, FLAGS.tool, FLAGS.verify_output) compiler_name = 'clang' if compiler == 'llvm' else 'opt' if compiler_name not in results: results[compiler_name] = {} results[compiler_name][level] = { 'goal': goal_value, 'seq': ['-{}'.format(level)] } IO.dump_yaml(results, filename)
def run(self, benchmark): """Random algorithm. Argument --------- benchmark: str """ self.__results = {} counter = 0 stop = False while True: # Create N sequences sequences = Sequence.create_random_sequences( self.__flags.nof_sequences, self.__flags.minimum, self.__flags.maximum, self.__flags.factor, self.__flags.ssa, self.__flags.shuffle, self.__flags.update, self.__flags.repetition, self.__flags.original, self.__flags.passes_filename) # For each sequence for _, data in sequences.items(): sequence = data['seq'] # Calculate the fitness if Sequence.exist(sequence, self.__results): continue index = benchmark.find('.') goal_value = Engine.evaluate( self.__flags.goals, Sequence.name_pass_to_string(sequence), self.__flags.compiler, os.path.join(self.__flags.benchmarks_directory, benchmark[:index], benchmark[index + 1:]), self.__flags.working_set, self.__flags.times, self.__flags.tool, self.__flags.verify_output) if goal_value == float('inf'): continue # Store the results self.__results[counter] = {'seq': sequence, 'goal': goal_value} counter += 1 if counter == self.__flags.nof_sequences: stop = True break if stop: break
def fitness(self, sequence): """Calculate and return the fitness.""" sequence = Sequence.fix_index(list(sequence)) sequence = Sequence.sanitize(sequence) sequence = Sequence.index_pass_to_list(sequence, self.passes_dict) goal_value = Engine.evaluate(self.goal, Sequence.name_pass_to_string( sequence ), self.compiler, self.benchmark_directory, self.working_set, self.times, self.tool, self.verify_output) return [goal_value]
def execute(argv): """Evaluate N sequences""" del argv FLAGS = flags.FLAGS # The benchmarks benchmarks = IO.load_yaml_or_fail(FLAGS.benchmarks_filename) if not benchmarks: logging.error('There are no benchmarks to process') sys.exit(1) # Create the results directory try: os.makedirs(FLAGS.results_directory) except FileExistsError: pass # Process each benchmark for benchmark in tqdm(benchmarks, desc='Processing'): # The benchmark index = benchmark.find('.') suite = benchmark[:index] bench_name = benchmark[index + 1:] # Create the results directory for the suite results_dir = os.path.join(FLAGS.results_directory, suite) try: os.makedirs(results_dir) except FileExistsError: pass # Verify report if FLAGS.suffix: output_filename = '{}/{}_{}.yaml'.format(results_dir, bench_name, FLAGS.suffix) else: output_filename = '{}/{}.yaml'.format(results_dir, bench_name) if FLAGS.verify_report and os.path.isfile(output_filename): continue # Benchmark directory bench_dir = os.path.join(FLAGS.benchmarks_directory, suite, bench_name) if not os.path.isdir(bench_dir): logging.error('Benchmark {} does not exist.'.format(benchmark)) sys.exit(1) # The training data training_dir = os.path.join(FLAGS.training_directory, suite) filename = '{}/{}.yaml'.format(training_dir, bench_name) sequences = IO.load_yaml_or_fail(filename) if not sequences: logging.error('There are no sequences to process') sys.exit(1) best_sequence = Sequence.get_the_best(sequences) # Verify if the best sequence is better than the baseline baseline_dir = os.path.join(FLAGS.baseline_directory, suite) filename = '{}/{}.yaml'.format(baseline_dir, bench_name) baseline_data = IO.load_yaml_or_fail(filename) if not baseline_data: logging.error('There are no baseline data') sys.exit(1) baseline_goal = baseline_data[FLAGS.compiler][FLAGS.baseline]['goal'] for _, data in best_sequence.items(): best_sequence_goal = data['goal'] if not (best_sequence_goal < baseline_goal): continue sequences = split_sequence(best_sequence) # Process the sequences results = {} for key, data in sequences.items(): goal_value = Engine.evaluate( Goals.prepare_goals(FLAGS.goals, FLAGS.weights), Sequence.name_pass_to_string(data['seq']), 'opt', bench_dir, FLAGS.working_set, FLAGS.times, FLAGS.tool, FLAGS.verify_output) results[key] = {'seq': data['seq'], 'goal': goal_value} # Store the results IO.dump_yaml(results, output_filename)
def run(self, benchmark, sequence): """This method invokes C-Reduce to create a small benchmark. Argument ---------- benchmark : str sequence : list Return ------ ret : bool True if reduction ok, otherwise False. """ index = benchmark.find('.') bench_in_dir = os.path.join(self.__flags.benchmarks_directory, benchmark[:index], benchmark[index+1:]) if not os.path.isdir(bench_in_dir): lg.error('The directory {} does not exist.'.format(bench_in_dir)) sys.exit(1) # 1. Calculate the difference (gain) # 1.1. Baseline's goal value baseline_goal_value = Engine.evaluate(self.__flags.goals, self.__flags.baseline, self.__flags.compiler, bench_in_dir) # 1.2. Sequence's goal value sequence_goal_value = Engine.evaluate(self.__flags.goals, Sequence.name_pass_to_string( sequence ), self.__flags.compiler, bench_in_dir) diff = int(baseline_goal_value - sequence_goal_value) if diff <= 0: lg.info( 'Warning: It is not possible to reduce the code ({}).'.format( diff ) ) return False # 2. Prepare the benchmark bench_out_dir = os.path.join(self.__flags.output_directory, benchmark[:index], benchmark[index+1:]) try: os.makedirs(bench_out_dir) except FileExistsError: pass cmdline = 'cp {0}/*.c {1}'.format(bench_in_dir, bench_out_dir) try: subprocess.run(cmdline, shell=True, check=True, capture_output=False) except subprocess.CalledProcessError: lg.fatal('Prepare the benchmark') # 3. Create the C-Reduce script filename = '{}/test.sh'.format(bench_out_dir) fout = open(filename, 'w') fout.write('#!/bin/bash\n') fout.write('DIFF={}\n'.format(diff)) fout.write('LIB=libMilepostStaticFeatures.so\n') fout.write('PASSES="{}"\n'.format( Sequence.name_pass_to_string(sequence)) ) fout.write('clang -Xclang -disable-O0-optnone -S -w -c -emit-llvm *.c\n') fout.write('llvm-link *.ll -S -o creduce.ll\n') fout.write('opt --disable-output -load $LIB {} \ --msf creduce.ll 2> msf.txt\n'.format(self.__flags.baseline)) fout.write('size_Oz=`grep f25 msf.txt | \ awk \'{total += $NF} END { print total }\'`\n') fout.write('rm -f msf.txt\n') fout.write('opt --disable-output -load $LIB \ $PASSES --msf creduce.ll 2> msf.txt\n') fout.write('size_PASSES=`grep f25 msf.txt | \ awk \'{total += $NF} END { print total }\'`\n') fout.write('rm -f msf.txt\n') fout.write('diff=$(($size_Oz-$size_PASSES))\n') fout.write('if [[ $diff -eq $DIFF ]]; then\n') fout.write(' exit 0\n') fout.write('else\n') fout.write(' exit 1\n') fout.write('fi\n') fout.close() cmdline = 'chmod +x {}/test.sh'.format(bench_out_dir) try: subprocess.run(cmdline, shell=True, check=True, capture_output=False) except subprocess.CalledProcessError: lg.fatal('Writing C-Reduce script') # 4. Invoke C-Reduce prefix = '{}/'.format(bench_out_dir) sources = glob.glob('{}*.c'.format(prefix)) sources = [source.replace(prefix, '').replace('.c', '') for source in sources] sources = ''.join(sources) cmdline = 'cd {0} ; creduce ./test.sh \ {1}.c > creduce.log 2> creduce.log'.format(bench_out_dir, sources) try: subprocess.run(cmdline, shell=True, check=True, capture_output=False) except subprocess.CalledProcessError: lg.fatal('Invoke C-Reduce') # 5. Create the new benchmark directory cmdline = 'cp {0}/Makefile.* {0}/compile.sh {1}'.format(bench_in_dir, bench_out_dir) try: subprocess.run(cmdline, shell=True, check=True, capture_output=False) except subprocess.CalledProcessError: lg.fatal('Invoke C-Reduce - Move the small file') return True
def run(self, sequence, benchmark): """Sequence Reduction algorithm. Suresh Purini and Lakshya Jain. Finding Good Optimization Sequences Covering Program Space. TACO. 2013 Argument -------- sequence : list benchmark : str """ # Calculate the initial value of the goal. index = benchmark.find('.') bench_dir = os.path.join(self.__flags.benchmarks_directory, benchmark[:index], benchmark[index + 1:]) goal_value = Engine.evaluate(self.__flags.goals, Sequence.name_pass_to_string(sequence), self.__flags.compiler, bench_dir, self.__flags.working_set, self.__flags.times, self.__flags.tool, self.__flags.verify_output) # Store the initial value of the goal. self.__results[0] = {'seq': sequence, 'goal': goal_value} # Sequence Reduction algorithm lst_best_sequence = sequence.copy() best_goal_value = goal_value change = True while change: change = False bestseqlen = len(lst_best_sequence) for i in range(bestseqlen): vector = [1 for i in range(bestseqlen)] vector[i] = 0 lst_new_sequence = Sequence.remove_passes( lst_best_sequence, vector) goal_value = Engine.evaluate( self.__flags.goals, Sequence.name_pass_to_string(lst_new_sequence), self.__flags.compiler, bench_dir, self.__flags.working_set, self.__flags.times, self.__flags.tool, self.__flags.verify_output) if goal_value <= best_goal_value: best_goal_value = goal_value lst_best_sequence = lst_new_sequence[:] change = True break goal_value = Engine.evaluate( self.__flags.goals, Sequence.name_pass_to_string(lst_best_sequence), self.__flags.compiler, bench_dir, self.__flags.working_set, self.__flags.times, self.__flags.tool, self.__flags.verify_output) # Store the final value of the goal. self.__results[1] = {'seq': lst_best_sequence, 'goal': goal_value}
def execute(argv): """Evaluate N sequences""" del argv FLAGS = flags.FLAGS # The benchmarks benchmarks = IO.load_yaml_or_fail(FLAGS.benchmarks_filename) if not benchmarks: logging.error('There are no benchmarks to process') sys.exit(1) # The sequences sequences = IO.load_yaml_or_fail(FLAGS.sequences_filename) if not sequences: logging.error('There are no benchmarks to process') sys.exit(1) # Create the results directory try: os.makedirs(FLAGS.results_directory) except FileExistsError: pass # Process each benchmark for benchmark in tqdm(benchmarks, desc='Processing'): index = benchmark.find('.') bench_dir = benchmark[:index] bench_name = benchmark[index+1:] bench_in_dir = os.path.join(FLAGS.benchmarks_directory, bench_dir, bench_name) if not os.path.isdir(bench_in_dir): continue bench_out_dir = os.path.join(FLAGS.results_directory, bench_dir) # Create the results directory for the suite try: os.makedirs(bench_out_dir) except FileExistsError: pass # Verify report if FLAGS.suffix: filename = '{}/{}_{}.yaml'.format( bench_out_dir, bench_name, FLAGS.suffix ) else: filename = '{}/{}.yaml'.format(bench_out_dir, bench_name) if FLAGS.verify_report and os.path.isfile(filename): continue # Process the sequences results = {} for key, data in sequences.items(): goal_value = Engine.evaluate( Goals.prepare_goals(FLAGS.goals, FLAGS.weights), Sequence.name_pass_to_string(data['seq']), 'opt', bench_in_dir, FLAGS.working_set, FLAGS.times, FLAGS.tool, FLAGS.verify_output ) results[key] = {'seq': data['seq'], 'goal': goal_value} # Store the results IO.dump_yaml(results, filename)
def execute(argv): """Generate random sequences for each benchmark""" FLAGS = flags.FLAGS results_directory = FLAGS.results_directory # Test benchmarks test_benchmarks = IO.load_yaml_or_fail(FLAGS.test_benchs_filename) if not test_benchmarks: logging.fatal('There are no test benchmarks to process') # Training benchmarks training_benchmarks = IO.load_yaml_or_fail(FLAGS.training_benchs_filename) if not training_benchmarks: logging.fatal('There are no training benchmarks to process') # Create the results directory try: os.makedirs(FLAGS.results_directory) except FileExistsError: pass # Extract the representation for test programs print(bold('1. EXTRACTING THE REPRESENTATION')) FLAGS.results_directory = os.path.join(results_directory, 'representation') FLAGS.benchmarks_filename = FLAGS.test_benchs_filename representation.execute(argv) # Distance: test --> training print(bold('2. MEASURING THE DISTANCE')) distance_results_directory = os.path.join(results_directory, 'distance') FLAGS.results_directory = distance_results_directory FLAGS.test_representation_directory = os.path.join(results_directory, 'representation') distance.execute(argv) # Process test benchmarks print(bold('3. PROCESSING THE BENCHMARKS')) for nof_sequences in tqdm(FLAGS.nof_sequences, desc='Processing'): for test_benchmark in test_benchmarks: index = test_benchmark.find('.') suite_name = test_benchmark[:index] bench_name = test_benchmark[index + 1:] # Find the best N sequences training_suite, sequences = find_sequences( test_benchmark, training_benchmarks, distance_results_directory, FLAGS.training_data_directory, int(nof_sequences)) # Goal_name if len(FLAGS.goals) > 1: goal_name = '_'.join(FLAGS.goals) else: goal_name = FLAGS.goals[0] # Create the results directory for the suite results_dir = os.path.join(results_directory, 'predictive_compilation', training_suite, goal_name) try: os.makedirs(results_dir) except FileExistsError: pass filename = '{}/{}_j{}.yaml'.format(results_dir, bench_name, nof_sequences) if FLAGS.verify_report and os.path.isfile(filename): continue results = {} for key, data in sequences.items(): goal_value = Engine.evaluate( Goals.prepare_goals(FLAGS.goals, FLAGS.weights), Sequence.name_pass_to_string(data['seq']), 'opt', os.path.join(FLAGS.benchmarks_directory, suite_name, bench_name), FLAGS.working_set, FLAGS.times, FLAGS.tool, FLAGS.verify_output) results[key] = {'seq': data['seq'], 'goal': goal_value} IO.dump_yaml(results, filename)