def process_type(t, df, plot_args, benchmark_order): if t == "perf": df = prepare.calculate_overhead(df, column="time") prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) filter_inputs(df) plot = draw.VarBarplotOverhead() plot_args.update({ "ylabel": "Normalized runtime\n(w.r.t. native)", "logy": True, }) elif t == "mem": df = prepare.calculate_overhead(df, column="maxsize") prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) filter_inputs(df) plot = draw.VarBarplotOverhead() plot_args.update({ "ylabel": "Memory overhead\n(w.r.t. native)", "logy": True, }) return plot, []
def main(t="perf"): logging.info("Processing data") if t == "perf": df = prepare.process_results("perf") df = prepare.calculate_overhead(df, column="cycles", over_compilertype="gcc-native") prepare.reorder_compilers(df, t) draw.barplot_overhead(df, filename="phoenix_%s.pdf" % t, ylim=(0, 2.7), yticks=range(0, 3), ylabel="Normalized runtime\n(w.r.t. native GCC)", figsize=(5, 3)) else: logging.error("Unknown plot type") exit(-1)
def main(t="perf"): logging.info("Processing data") df = prepare.process_results(t) if t == "tput": prepare.reorder_compilers(df, t) plot = draw.LinePlotTput() plot.get_data(df, []) plot.build_plot( # xlim=(0, 55), xticks=range(0, 100, 10), # ylim=(0.15, 0.72), yticks=np.arange(0.1, 1, 0.1), ) plot.save_plot("nginx_%s.pdf" % t) else: logging.error("Unknown plot type") exit(-1)
def main(t="perf"): logging.info("Processing data") df = prepare.process_results(t) if t == "tput": df["lat"] /= 1000 prepare.reorder_compilers(df, t) plot = draw.LinePlotTput() plot.get_data(df, []) plot.build_plot(xlim=(90, 290), xticks=range(100, 300, 50), ylim=(0.0, 3.0), yticks=np.arange(0.5, 3.0, 0.5), legend_loc='upper right') plot.save_plot("memcached_%s.pdf" % t) else: logging.error("Unknown plot type") exit(-1)
def main(t="perf"): logging.info("Processing data") df = prepare.process_results(t) if t == "tput": prepare.reorder_compilers(df, t) plot = draw.LinePlotTput() plot.get_data(df, []) plot.build_plot( xlim=(0, 65), xticks=range(0, 100, 10), ylim=(0.1, 0.8), yticks=np.arange(0.2, 0.79, 0.1), legend_loc=(0.01, 0.45), figsize=(5, 2.5), ) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) else: logging.error("Unknown plot type") exit(-1)
def process_type(t, df, plot_args, benchmark_order): columns = [] # type specific processing if t == "perf": df = prepare.calculate_overhead(df) prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Normalized runtime\n(w.r.t. native)", "logy": True, }) elif t == "mem": df = prepare.calculate_overhead(df, column="maxsize") prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Memory overhead\n(w.r.t. native)", "logy": True, }) elif t == "multi": df = prepare.calculate_overhead(df) prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) # df.sort_values(["threads"], inplace=True) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Scaling", "ylim": (0.95, 1.4), "logy": False, "ncol": 5, }) else: logging.error("Unknown plot type") exit(-1) # no need to return plot_args, dict is mutable and is passed by reference return plot, columns
def main(t="tput"): logging.info("Processing data") if t == "tput": df = prepare.process_results(t) # NOTE: specific names and order names = ["bin/httpd", "nginx", "bin/memcached"] # df["name"].unique() titles = ["Apache", "Nginx", "Memcached"] # df["name"].unique() idxs = ["(a)", "(b)", "(c)"] fig = plt.figure() plot = draw.LinePlotTput() for idx, name in enumerate(names): sub = fig.add_subplot(1, len(names), idx + 1) dff = df[df["name"] == name].copy() prepare_specific(name, dff) # NOTE 1: since all compilers perform roughly the same, we leave gcc only for simplicity prepare.reorder_compilers(dff, t) limits = limits_specific(name) plot.get_data(dff, []) xlabel = " " ylabel = "" if idx == 1: xlabel = r"Throughput ($\times 10^3$ msg/s)" if idx == 0: ylabel = r"Latency (ms)" plot.build_plot( xlabel=xlabel, ylabel=ylabel, subplot=sub, xlim=limits["xlim"], xticks=limits["xticks"], ylim=limits["ylim"], yticks=limits["yticks"], figsize=(12, 3), ) subplot = plot.get_current_subplot() subplot.text(0.5, 1.02, idxs[idx] + " " + titles[idx], fontsize=12, horizontalalignment='center', transform=subplot.transAxes) for showlegendname in ["nginx"]: if showlegendname not in name: subplot.legend().set_visible(False) plot.save_plot(filename="merged_%s.pdf" % t) elif t == "perf": plot_args = { "ylabel": "Normalized runtime\n(w.r.t. native)", "ylim": (0.85, 10), "vline_position": 2.5, "logy": True, "text_points": OVERFLOWS.get(t, ()) } (file_name, df) = prepare.read_raw() plot = draw.BarplotOverhead() plot.df = df plot.df = plot.df.set_index("name") plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "mem": plot_args = { "ylabel": "Memory overhead\n(w.r.t. native)", "ylim": (0.85, 10), "vline_position": 2.5, "logy": True, "text_points": OVERFLOWS.get(t, ()) } (file_name, df) = prepare.read_raw() plot = draw.BarplotOverhead() plot.df = df plot.df = plot.df.set_index("name") plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "mpxcount": (file_name, df) = prepare.read_raw() prepare.reorder_compilers(df, t) labels = df["compilertype"].unique() plot_args = { "ylabel": "MPX instructions\n(w.r.t. all instructions, %)", "xlabels": labels, "ylim": (0, 52), "yticks": range(0, 90, 10), "df_callback": prepare.reorder_and_rename_benchmarks, "df_callback_args": (BENCHMARK_ORDER, ) } plot = draw.BarplotClusteredStacked() plot.columns = [ "bndcl", "bndcu", "bndldx", "bndstx", "bndmovreg", "bndmovmem" ] plot.df = df plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "multi": plot_args = { "ylabel": "Speedup of 8 threads \nw.r.t. 2 threads", "ylim": (0.51, 4.5), "vline_position": 1.5, "logy": True, } (file_name, df) = prepare.read_raw() plot = draw.BarplotMultithreaded() plot.df = df plot.df = plot.df.set_index("name") plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "cache": (file_name, df) = prepare.read_raw() prepare.reorder_compilers(df, t) labels = df["compilertype"].unique() plot_args = { "ylabel": "Cache hits and misses\n(w.r.t. all instructions, %)", "xlabels": labels, "ylim": (0, 100), "yticks": range(0, 150, 20), "df_callback": prepare.reorder_and_rename_benchmarks, "df_callback_args": (BENCHMARK_ORDER, ) } plot = draw.BarplotClusteredStacked() plot.columns = [ "L1 load hits", "L1 store hits", "L2 load hits", "LLC load hits", "LLC load misses", "LLC store misses" ] plot.df = df plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "instr": plot_args = { "ylabel": "Instruction overhead\n(w.r.t. native)", "ylim": (0.85, 10), "vline_position": 2.5, "logy": True, "text_points": OVERFLOWS.get(t, ()) } (file_name, df) = prepare.read_raw() plot = draw.BarplotOverhead() plot.df = df plot.df = plot.df.set_index("name") plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "ipc": plot_args = { "ylabel": "Processor IPC\n(instructions/cycle)", "ylim": (0, 5.4), "vline_position": 2.5, "yticks": range(0, 10, 1), "ncol": 6, } (file_name, df) = prepare.read_raw() plot = draw.BarplotWithNative() plot.df = df plot.df = plot.df.set_index("name") plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "mpx_feature_perf": plot_args = { "ylabel": "Normalized runtime\n(w.r.t. native)", "ylim": (0.85, 10), "vline_position": 2.5, "build_names": "mpx_feature", "logy": True, "ncol": 6, } (file_name, df) = prepare.read_raw() plot = draw.BarplotMPXFature() plot.df = df plot.df = plot.df.set_index("name") plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) elif t == "mpx_feature_mem": plot_args = { "ylabel": "Memory overhead\n(w.r.t. native)", "ylim": (0.85, 10), "vline_position": 2.5, "build_names": "mpx_feature", "logy": True, "ncol": 6, } (file_name, df) = prepare.read_raw() plot = draw.BarplotMPXFature() plot.df = df plot.df = plot.df.set_index("name") plot.build_plot(**plot_args) plot.save_plot("%s_%s.pdf" % (BENCH_NAME, t)) else: logging.error("Unknown plot type") exit(-1)
def process_type(t, df, plot_args, benchmark_order): columns = [] # type specific processing if t == "perf": df = prepare.calculate_overhead(df) prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Normalized runtime\n(w.r.t. native)", "logy": True, }) elif t == "mem": df = prepare.calculate_overhead(df, column="maxsize") prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Memory overhead\n(w.r.t. native)", "logy": True, }) elif t == "mpxcount": columns = ["bndcl", "bndcu", "bndldx", "bndstx", "bndmovreg", "bndmovmem"] df = prepare.calculate_ratio(df, columns, "instructions") prepare.reorder_compilers(df, t) labels = df["compilertype"].unique() for column in columns: df[column] *= 100 plot = draw.BarplotClusteredStacked() plot_args.update({ "ylabel": "MPX instructions\n(w.r.t. all instructions, %)", "xlabels": labels, "ylim": (0, 52), "yticks": range(0, 90, 10), "df_callback": prepare.reorder_and_rename_benchmarks, "df_callback_args": (benchmark_order,) }) elif t == "multi": df = prepare.calculate_multithreading_overhead(df, over=2) prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) df["threads"] = Categorical(df["threads"], [8]) df.sort_values(["threads"], inplace=True) plot = draw.BarplotMultithreaded() plot_args.update({ "ylabel": "Speedup of 8 threads \nw.r.t. 2 threads", "ylim": (0.9, 4.5), "logy": True, }) elif t == "cache": # values over 1000 instructions columns = ["l1_dcache_loads", "l1_dcache_load_misses", "l1_dcache_stores", "l1_dcache_store_misses", "llc_loads", "llc_load_misses", "llc_stores", "llc_store_misses"] df = prepare.calculate_ratio(df, columns, "instructions") for c in columns: df[c] *= 100 # differences df["L1 load hits"] = df["l1_dcache_loads"] - df["l1_dcache_load_misses"] df["LLC load hits"] = df["llc_loads"] - df["llc_load_misses"] df["L2 load hits"] = df["l1_dcache_load_misses"] - df["LLC load hits"] df["LLC load misses"] = df["llc_load_misses"] # df["l1_dcache_store_hits"] = df["l1_dcache_stores"] - df["l1_dcache_store_misses"] df["L1 store hits"] = df["l1_dcache_stores"] - df["llc_store_misses"] df["LLC store misses"] = df["llc_store_misses"] # ordering prepare.reorder_compilers(df, t) df = df.dropna(subset=['compilertype', 'name']) labels = df["compilertype"].unique() columns = ["L1 load hits", "L1 store hits", "L2 load hits", "LLC load hits", "LLC load misses", "LLC store misses"] plot = draw.BarplotClusteredStacked() plot_args.update({ "ylabel": "Cache hits and misses\n(w.r.t. all instructions, %)", "xlabels": labels, "ylim": (0, 100), "yticks": range(0, 150, 20), "df_callback": prepare.reorder_and_rename_benchmarks, "df_callback_args": (benchmark_order,) }) elif t == "instr": df = prepare.calculate_overhead(df, column="instructions") prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Instruction overhead\n(w.r.t. native)", "logy": True, }) elif t == "misc_stat": # values over 1000 instructions columns = ["dtlb_stores", "dtlb_store_misses", "dtlb_load_misses", "dtlb_loads", "branch_misses", "branch_instructions"] df = prepare.calculate_ratio(df, columns, "instructions") for c in columns: df[c] *= 100 # differences df["dtlb_stores"] -= df["dtlb_store_misses"] df["dtlb_loads"] -= df["dtlb_load_misses"] df["branch_instructions"] -= df["branch_misses"] prepare.reorder_compilers(df, t) df = df.dropna(subset=['compilertype', 'name']) labels = df["compilertype"].unique() plot = draw.BarplotClusteredStacked() plot_args.update({ "ylabel": "Other statistics\n(w.r.t. all instructions, %)", "xlabels": labels, "ylim": (0, 100), "yticks": range(0, 150, 20), "df_callback": prepare.reorder_and_rename_benchmarks, "df_callback_args": (benchmark_order,) }) elif t == "ku_instr": df = prepare.calculate_overhead(df, column="instructions:k") prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Kernel instruction overhead\n(w.r.t. native)", "logy": True, }) elif t == "native_mem_access": # values over 1000 instructions columns = ["l1_dcache_loads", "l1_dcache_stores"] df = prepare.calculate_ratio(df, columns, "instructions") df["overhead"] = df["l1_dcache_loads"] + df["l1_dcache_stores"] df["overhead"] *= 100 prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotOverhead() plot_args.update({ "ylabel": "Memory accesses\n(w.r.t. all instructions, %)", "ylim": (0, 115), "yticks": range(0, 101, 20), }) elif t == "ipc": # IPC (instructions/cycle) is saved in "instructions" column df = prepare.calculate_ratio(df, ["instructions"], "cycles") df["overhead"] = df["instructions"] prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotWithNative() plot_args.update({ "ylabel": "Processor IPC\n(instructions/cycle)", "ylim": (0, 5.4), "yticks": range(0, 10, 1), "ncol": 6, }) elif t == "mpx_feature_perf": df = prepare.calculate_overhead(df) prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotMPXFature() plot_args.update({ "ylabel": "Normalized runtime\n(w.r.t. native)", "build_names": "mpx_feature", "logy": True, "ncol": 6, }) elif t == "mpx_feature_mem": df = prepare.calculate_overhead(df, column="maxsize") prepare.reorder_and_rename_benchmarks(df, benchmark_order) prepare.reorder_compilers(df, t) plot = draw.BarplotMPXFature() plot_args.update({ "ylabel": "Memory overhead\n(w.r.t. native)", "build_names": "mpx_feature", "logy": True, "ncol": 6, }) else: logging.error("Unknown plot type") exit(-1) # no need to return plot_args, dict is mutable and is passed by reference return plot, columns