Commit 9bb9ab8f5d660b739af8109e0356721c296ae0cb
1 parent
4628b929
notuning vs wtuning
Showing
1 changed file
with
204 additions
and
0 deletions
figures/notuning_wtuning.py
0 → 100644
| 1 | +import os, sys, argparse | |
| 2 | +import numpy | |
| 3 | +import matplotlib.pyplot as plt | |
| 4 | +import json | |
| 5 | +from pylab import * | |
| 6 | +from mpl_toolkits.mplot3d import Axes3D | |
| 7 | +from matplotlib.patches import Rectangle | |
| 8 | +from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas | |
| 9 | +from sets import Set | |
| 10 | + | |
| 11 | +from common import * | |
| 12 | + | |
| 13 | +def get_energy(frontiers_data, cpu_freq, mem_freq, sample): | |
| 14 | + for point in frontiers_data["data"][sample]: | |
| 15 | + if point["cpu_freq"] == cpu_freq: | |
| 16 | + if point["mem_freq"] == mem_freq: | |
| 17 | + return point["energy"] | |
| 18 | + | |
| 19 | +def get_performance(frontiers_data, cpu_freq, mem_freq, sample): | |
| 20 | + for point in frontiers_data["data"][sample]: | |
| 21 | + if point["cpu_freq"] == cpu_freq: | |
| 22 | + if point["mem_freq"] == mem_freq: | |
| 23 | + return point["performance"] | |
| 24 | + | |
| 25 | +def get_aggr_energy(frontiers_data, cpu_freq, mem_freq): | |
| 26 | + for point in frontiers_data["data"]: | |
| 27 | + if point["cpu_freq"] == cpu_freq: | |
| 28 | + if point["mem_freq"] == mem_freq: | |
| 29 | + return point["energy"] | |
| 30 | + | |
| 31 | +def get_aggr_performance(frontiers_data, cpu_freq, mem_freq): | |
| 32 | + for point in frontiers_data["data"]: | |
| 33 | + if point["cpu_freq"] == cpu_freq: | |
| 34 | + if point["mem_freq"] == mem_freq: | |
| 35 | + return point["performance"] | |
| 36 | + | |
| 37 | +def get_no_tuning_energy_performance(args, budget, bmark): | |
| 38 | + dir_path = args.input_dir | |
| 39 | + | |
| 40 | + # finding points with 3% threshold of target budget/inefficiency | |
| 41 | + thresh = 3 | |
| 42 | + | |
| 43 | + bmarkDirPath = os.path.join(os.path.join(dir_path, "aggr_data"), bmark) | |
| 44 | + frontiers_file = os.path.join(bmarkDirPath, "frontiers.json") | |
| 45 | + frontiers_data = json.loads(open(frontiers_file).read()) | |
| 46 | + | |
| 47 | + filtered_data=[] | |
| 48 | + for point in frontiers_data["data"]: | |
| 49 | + #filtering all those points which have inefficiency with error% of the budget | |
| 50 | + if point["inefficiency"] <= budget: | |
| 51 | + filtered_data.append(point) | |
| 52 | + elif (point["inefficiency"] - budget) * 100 / budget <= thresh: | |
| 53 | + filtered_data.append(point) | |
| 54 | + | |
| 55 | + #finding the point with highest performance among filtered data | |
| 56 | + optimal_point = filtered_data[0] | |
| 57 | + for point in filtered_data: | |
| 58 | + if point["speedup"] > optimal_point["speedup"]: | |
| 59 | + optimal_point = point | |
| 60 | + | |
| 61 | + energy = get_aggr_energy(frontiers_data, optimal_point["cpu_freq"], optimal_point["mem_freq"]) | |
| 62 | + performance = get_aggr_performance(frontiers_data, optimal_point["cpu_freq"], optimal_point["mem_freq"]) | |
| 63 | + energy = energy/1e6 | |
| 64 | + performance = performance/1e6 | |
| 65 | + | |
| 66 | + return (energy, performance) | |
| 67 | + | |
| 68 | +def energy_time(args, budget_list, cluster_thresh, perf_cost, energy_cost): | |
| 69 | + dir_path = args.input_dir | |
| 70 | + output_dir_path = args.output_dir | |
| 71 | + | |
| 72 | + benchmarks, labels = get_benchmarks(args) | |
| 73 | +# benchmarks =['bzip2'] | |
| 74 | + #plot constants | |
| 75 | + cpuflist = get_cpu_freq_plot_list(args) | |
| 76 | + memflist = get_mem_freq_plot_list(args) | |
| 77 | + | |
| 78 | + # finding points with 3% threshold of target budget/inefficiency | |
| 79 | + thresh = 3 | |
| 80 | + energy_data = [ [] for thresh in budget_list] | |
| 81 | + performance_data = [ [] for thresh in budget_list] | |
| 82 | + for bmark in benchmarks: | |
| 83 | + data = [] | |
| 84 | + for budget_index, budget in enumerate(budget_list): | |
| 85 | + print "Inefficiency Budget: "+str(budget)+" Benchmark: "+bmark | |
| 86 | + | |
| 87 | + energy_notuning, performance_notuning = get_no_tuning_energy_performance(args, budget, bmark) | |
| 88 | + print "no.tuning: performance (ms): "+str(performance_notuning)+" energy(mJ): "+str(energy_notuning) | |
| 89 | + | |
| 90 | + bmarkDirPath = os.path.join(os.path.join(dir_path, "per_sample_data"), bmark) | |
| 91 | + frontiers_file = os.path.join(bmarkDirPath, "per_sample_frontiers.json") | |
| 92 | + frontiers_data = json.loads(open(frontiers_file).read()) | |
| 93 | + | |
| 94 | + data_to_plot=[] | |
| 95 | + sample_points=[] | |
| 96 | + cpu_rectangle_points=[] | |
| 97 | + for data in frontiers_data["data"]: | |
| 98 | + filtered_data=[] | |
| 99 | + #filtering all those points which have inefficiency with error% of the budget | |
| 100 | + for point in data: | |
| 101 | + if point["inefficiency"] <= budget: | |
| 102 | + filtered_data.append(point) | |
| 103 | + elif (point["inefficiency"] - budget) * 100 / budget <= thresh: | |
| 104 | + filtered_data.append(point) | |
| 105 | + | |
| 106 | + #finding the point with highest performance among filtered data | |
| 107 | + optimal_point = filtered_data[0] | |
| 108 | + for point in filtered_data: | |
| 109 | + if point["speedup"] > optimal_point["speedup"]: | |
| 110 | + optimal_point = point | |
| 111 | + | |
| 112 | + local_rect_points=[] | |
| 113 | + for point in filtered_data: | |
| 114 | + if (optimal_point["speedup"] - point["speedup"]) < 0: | |
| 115 | + print "something is wrong!" | |
| 116 | + | |
| 117 | + if (optimal_point["speedup"] - point["speedup"]) * 100 / optimal_point["speedup"] <= cluster_thresh: | |
| 118 | + data_to_plot.append(point) | |
| 119 | + sample_points.append(frontiers_data["data"].index(data)) | |
| 120 | + local_rect_points.append(point) | |
| 121 | + | |
| 122 | + cpufpoints = [cpuf for cpuf in [data_to_plot[sample]["cpu_freq"] for sample in range(len(data_to_plot))]] | |
| 123 | + memfpoints = [memf for memf in [data_to_plot[sample]["mem_freq"] for sample in range(len(data_to_plot))]] | |
| 124 | + samplepoints = sample_points | |
| 125 | + | |
| 126 | + #Total number of transitions | |
| 127 | + num_transitions = 0.0 | |
| 128 | + #Available settings for (CPU, MEM) | |
| 129 | + settings_available = Set() | |
| 130 | + index = 0 | |
| 131 | + current_sample = -1 | |
| 132 | + length = 1 | |
| 133 | + lengths = [] | |
| 134 | + prev_tr_sample = 0 | |
| 135 | + energy = 0 | |
| 136 | + performance = 0 | |
| 137 | + while index < len( samplepoints ): | |
| 138 | + current_sample = samplepoints[index] | |
| 139 | + | |
| 140 | + #Construct the current settings | |
| 141 | + current_settings = Set() | |
| 142 | + while index < len( samplepoints ) and samplepoints[index] == current_sample: | |
| 143 | + current_settings.add((cpufpoints[index],memfpoints[index])) | |
| 144 | + index = index + 1 | |
| 145 | + | |
| 146 | + #Compute the common points between current and what is available | |
| 147 | + common_points = current_settings.intersection(settings_available) | |
| 148 | + | |
| 149 | + if (len(common_points) == 0 or index == len( samplepoints )): | |
| 150 | + # find the point with highest cpu and mem freq | |
| 151 | + if (current_sample !=0 ): | |
| 152 | + optimal_point = settings_available.pop() | |
| 153 | + settings_available.add(optimal_point) | |
| 154 | + for point in settings_available: | |
| 155 | + if point[0] > optimal_point[0]: | |
| 156 | + optimal_point = point | |
| 157 | + elif point[0] == optimal_point[0]: | |
| 158 | + if point[1] > optimal_point[1]: | |
| 159 | + optimal_point = point | |
| 160 | + done = 0 | |
| 161 | + idx = prev_tr_sample+1 | |
| 162 | + while done == 0: | |
| 163 | + energy += get_energy(frontiers_data, optimal_point[0], optimal_point[1], idx) | |
| 164 | + performance += get_performance(frontiers_data, optimal_point[0], optimal_point[1], idx) | |
| 165 | + if idx == samplepoints[index-1]: | |
| 166 | + done = 1 | |
| 167 | + else: | |
| 168 | + idx += 1 | |
| 169 | + | |
| 170 | + prev_tr_sample = samplepoints[index-1] | |
| 171 | + | |
| 172 | + # When there are no common points, transition | |
| 173 | + if (len(common_points) == 0): | |
| 174 | + settings_available = current_settings #all current settings are now available | |
| 175 | + #Ignore the transition if it's the first sample | |
| 176 | + if (current_sample!=0): | |
| 177 | + num_transitions += 1 | |
| 178 | + else: # Continue with the common points | |
| 179 | + settings_available = common_points | |
| 180 | + | |
| 181 | + # Record the length if we need to transition or we are at the end | |
| 182 | + if (len(common_points) == 0 or index == len( samplepoints )): | |
| 183 | + #Ignore the length if the transition is for the first sample | |
| 184 | + if (current_sample!=0): | |
| 185 | + lengths.append(length) | |
| 186 | + #reset the length | |
| 187 | + length = 1 | |
| 188 | + else: #otherwise, just increment the length | |
| 189 | + length += 1 | |
| 190 | + | |
| 191 | + energy = (energy + (num_transitions * energy_cost))/1e6 | |
| 192 | + performance = (performance +(num_transitions * perf_cost))/1e6 | |
| 193 | + energy_data[budget_index].append(energy) | |
| 194 | + performance_data[budget_index].append(performance) | |
| 195 | + print "w.tuning: performance (ms): "+str(performance)+" energy(mJ): "+str(energy) +"\n" | |
| 196 | + | |
| 197 | +def main(argv): | |
| 198 | + args = parse(argv) | |
| 199 | + | |
| 200 | + for thresh in [0.0]: | |
| 201 | + energy_time(args, [1.0,1.1, 1.2, 1.3,1.6,3.0], thresh, 0, 0) | |
| 202 | + | |
| 203 | +if __name__ == "__main__": | |
| 204 | + main(sys.argv) | ... | ... |