Add Non-Notebook scripts for visalization

2-Performance_Counters/Handson/.master/graphing.py

+import matplotlib as mpl
+mpl.use('Agg')
 import matplotlib.pyplot as plt
-import pandas as pd
+import numpy as np
 import seaborn as sns
+import pandas as pd
+import common
 sns.set()
 plt.rcParams['figure.figsize'] = [14, 6]
 
-import common
+def linear_function(x, a, b):
+    return a*x+b
 
 def task1(input="poisson2d.ins_cyc.bin.csv"):
-	df = pd.read_csv(input, skiprows=range(2, 50000, 2))  # Read in the CSV file from the bench run; parse with Pandas
-	common.normalize(df, "PM_INST_CMPL (min)", "Instructions / Loop Iteration")  # Normalize to each iteration
-	common.normalize(df, "PM_RUN_CYC (min)", "Cycles / Loop Iteration")
+	df = pd.read_csv("poisson2d.ins_cyc.bin.csv", skiprows=range(2, 50000, 2))  # Read in the CSV file from the bench run; parse with Pandas
+	df["Grid Points"] = df["nx"] * df["ny"]  # Add a new column of the number of grid points (the product of nx and ny)
+	fit_parameters, fit_covariance = common.print_and_return_fit(
+	    ["PM_RUN_CYC (min)", "PM_INST_CMPL (min)"], 
+	    df.set_index("Grid Points"), 
+	    linear_function,
+	    format_uncertainty=".4f"
+	)
 	fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True)
-	df.set_index("nx")["Cycles / Loop Iteration"].plot(ax=ax1, legend=True);
-	df.set_index("nx")["Instructions / Loop Iteration"].plot(ax=ax2, legend=True);
+	for ax, pmu_counter in zip([ax1, ax2], ["PM_RUN_CYC (min)", "PM_INST_CMPL (min)"]):
+	    df.set_index("Grid Points")[pmu_counter].plot(ax=ax, legend=True);
+	    ax.plot(
+	        df["Grid Points"], 
+	        linear_function(df["Grid Points"], *fit_parameters[pmu_counter]), 
+	        linestyle="--", 
+	        label="Fit: {:.2f} * x + {:.2f}".format(*fit_parameters[pmu_counter])
+	    )
+	    ax.legend();
 	fig.savefig("plot-task1.pdf")
 
 def task2a(input="poisson2d.ld_st.bin.csv"):
-	df_ldst = pd.read_csv(input, skiprows=range(2, 50000, 2))
-	common.normalize(df_ldst, "PM_LD_CMPL (min)", "Loads / Loop Iteration")
-	common.normalize(df_ldst, "PM_ST_CMPL (min)", "Stores / Loop Iteration")
+	df_ldst = pd.read_csv("poisson2d.ld_st.bin.csv", skiprows=range(2, 50000, 2))
+	df_ldst["Grid Points"] = df_ldst["nx"] * df_ldst["ny"] 
+	fit_parameters, fit_covariance = common.print_and_return_fit(
+	    ["PM_LD_CMPL (min)", "PM_ST_CMPL (min)"], 
+	    df_ldst.set_index("Grid Points"), 
+	    linear_function,
+	    format_value=".4f"
+	)
 	fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True)
-	df_ldst.set_index("nx")["Loads / Loop Iteration"].plot(ax=ax1, legend=True);
-	df_ldst.set_index("nx")["Stores / Loop Iteration"].plot(ax=ax2, legend=True);
+	for ax, pmu_counter in zip([ax1, ax2], ["PM_LD_CMPL (min)", "PM_ST_CMPL (min)"]):
+	    df_ldst.set_index("Grid Points")[pmu_counter].plot(ax=ax, legend=True);
+	    ax.plot(
+	        df_ldst["Grid Points"], 
+	        linear_function(df_ldst["Grid Points"], *fit_parameters[pmu_counter]), 
+	        linestyle="--", 
+	        label="Fit: {:.2f} * x + {:.2f}".format(*fit_parameters[pmu_counter])
+	    )
+	    ax.legend();
 	fig.savefig("plot-task2a.pdf")
 
 
-def task2b(input1="poisson2d.vld.bin.csv", input2="poisson2d.vst.bin.csv", input3="poisson2d.ld_st.bin.csv", bytes=False):
+def task2b(input1="poisson2d.vld.bin.csv", input2="poisson2d.vst.bin.csv", input3="poisson2d.ld_st.bin.csv", bytes=False, just_return=False):
 	df_vld = pd.read_csv(input1, skiprows=range(2, 50000, 2))
 	df_vst = pd.read_csv(input2, skiprows=range(2, 50000, 2))
 	df_vldvst = pd.concat([df_vld.set_index("nx"), df_vst.set_index("nx")[['PM_VECTOR_ST_CMPL (total)', 'PM_VECTOR_ST_CMPL (min)', ' PM_VECTOR_ST_CMPL (max)']]], axis=1).reset_index()
-	common.normalize(df_vldvst, "PM_VECTOR_LD_CMPL (min)", "Vector Loads / Loop Iteration")
-	common.normalize(df_vldvst, "PM_VECTOR_ST_CMPL (min)", "Vector Stores / Loop Iteration")
+	df_vldvst["Grid Points"] = df_vldvst["nx"] * df_vldvst["ny"] 
+	fit_parameters, fit_covariance = common.print_and_return_fit(
+	    ["PM_VECTOR_LD_CMPL (min)", "PM_VECTOR_ST_CMPL (min)"], 
+	    df_vldvst.set_index("Grid Points"), 
+	    linear_function,
+	    format_value=".4f",
+	)
 	if bytes is False:
 		fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True)
-		df_vldvst.set_index("nx")["Vector Loads / Loop Iteration"].plot(ax=ax1, legend=True);
-		df_vldvst.set_index("nx")["Vector Stores / Loop Iteration"].plot(ax=ax2, legend=True);
+		for ax, pmu_counter in zip([ax1, ax2], ["PM_VECTOR_LD_CMPL (min)", "PM_VECTOR_ST_CMPL (min)"]):
+		    df_vldvst.set_index("Grid Points")[pmu_counter].plot(ax=ax, legend=True);
+		    ax.plot(
+		        df_vldvst["Grid Points"], 
+		        linear_function(df_vldvst["Grid Points"], *fit_parameters[pmu_counter]), 
+		        linestyle="--", 
+		        label="Fit: {:.2f} * x + {:.2f}".format(*fit_parameters[pmu_counter])
+		    )
+		    ax.legend();
 		fig.savefig("plot-task2b.pdf")
 	else:
-		df_ldst = pd.read_csv(input3, skiprows=range(2, 50000, 2))
-		common.normalize(df_ldst, "PM_LD_CMPL (min)", "Loads / Loop Iteration")
-		common.normalize(df_ldst, "PM_ST_CMPL (min)", "Stores / Loop Iteration")
 		df_byte = pd.DataFrame()
-		df_byte["Loads / Loop Iteration"] = (df_vldvst.set_index("nx")["Vector Loads / Loop Iteration"] + df_ldst.set_index("nx")["Loads / Loop Iteration"])*8
-		df_byte["Stores / Loop Iteration"] = (df_vldvst.set_index("nx")["Vector Stores / Loop Iteration"] + df_ldst.set_index("nx")["Stores / Loop Iteration"])*8
+		df_ldst = pd.read_csv(input3, skiprows=range(2, 50000, 2))
+		df_ldst["Grid Points"] = df_ldst["nx"] * df_ldst["ny"] 
+		df_byte["Loads"]  = (df_vldvst.set_index("Grid Points")["PM_VECTOR_LD_CMPL (min)"] + df_ldst.set_index("Grid Points")["PM_LD_CMPL (min)"])*8
+		df_byte["Stores"] = (df_vldvst.set_index("Grid Points")["PM_VECTOR_ST_CMPL (min)"] + df_ldst.set_index("Grid Points")["PM_ST_CMPL (min)"])*8
+		if not just_return:
+			_fit, _cov = common.print_and_return_fit(
+			    ["Loads", "Stores"], 
+			    df_byte, 
+			    linear_function
+			)
+			fit_parameters = {**fit_parameters, **_fit}
+			fit_covariance = {**fit_covariance, **_cov}
 			fig, ax = plt.subplots()
-		ax = df_byte.plot(ax=ax)
-		ax.set_ylabel("Bytes / Loop Iteration");
+			for pmu_counter in ["Loads", "Stores"]:
+			    df_byte[pmu_counter].plot(ax=ax, legend=True);
+			    ax.plot(
+			        df_byte.index, 
+			        linear_function(df_byte.index, *fit_parameters[pmu_counter]), 
+			        linestyle="--", 
+			        label="Fit: {:.2f} * x + {:.2f}".format(*fit_parameters[pmu_counter])
+			    )
+			ax.legend();
+			ax.set_ylabel("Bytes");
 			fig.savefig("plot-task2b-2.pdf")
+		else:
+			return df_byte
 
 def task2c(input1="poisson2d.vld.bin.csv", input2="poisson2d.vst.bin.csv", input3="poisson2d.ld_st.bin.csv", input4="poisson2d.ins_cyc.bin.csv"):
 	df = pd.read_csv(input4, skiprows=range(2, 50000, 2))
@@ -77,29 +135,25 @@ def task4(input1="poisson2d.vld.bin.csv", input2="poisson2d.vst.bin.csv", input3
 	df_sflop = pd.read_csv(input5, skiprows=range(2, 50000, 2))
 	df_vflop = pd.read_csv(input6, skiprows=range(2, 50000, 2))
 	df_flop = pd.concat([df_sflop.set_index("nx"), df_vflop.set_index("nx")[['PM_VECTOR_FLOP_CMPL (total)', 'PM_VECTOR_FLOP_CMPL (min)', ' PM_VECTOR_FLOP_CMPL (max)']]], axis=1).reset_index()
-	common.normalize(df_flop, "PM_SCALAR_FLOP_CMPL (min)", "Scalar FlOps / Loop Iteration")
-	common.normalize(df_flop, "PM_VECTOR_FLOP_CMPL (min)", "Vector Instructions / Loop Iteration")
-	df_flop["Vector FlOps / Loop Iteration"] = df_flop["Vector Instructions / Loop Iteration"] * 2
+
+	df_flop["Grid Points"] = df_flop["nx"] * df_flop["ny"]
+	df_flop["Vector FlOps (min)"] = df_flop["PM_VECTOR_FLOP_CMPL (min)"] * 2
+	df_flop["Scalar FlOps (min)"] = df_flop["PM_SCALAR_FLOP_CMPL (min)"]
+	fit_parameters, fit_covariance = common.print_and_return_fit(
+	    ["Scalar FlOps (min)", "Vector FlOps (min)"], 
+	    df_flop.set_index("Grid Points"), 
+	    linear_function
+	)
 	if ai is False:
 		fig, ax = plt.subplots()
-		df_flop.set_index("nx")[["Scalar FlOps / Loop Iteration", "Vector FlOps / Loop Iteration"]].plot(ax=ax);
+		df_flop.set_index("Grid Points")[["Scalar FlOps (min)", "Vector FlOps (min)"]].plot(ax=ax);
 		fig.savefig("plot-task4.pdf")
 	else:
-		df_vld = pd.read_csv(input1, skiprows=range(2, 50000, 2))
-		df_vst = pd.read_csv(input2, skiprows=range(2, 50000, 2))
-		df_vldvst = pd.concat([df_vld.set_index("nx"), df_vst.set_index("nx")[['PM_VECTOR_ST_CMPL (total)', 'PM_VECTOR_ST_CMPL (min)', ' PM_VECTOR_ST_CMPL (max)']]], axis=1).reset_index()
-		common.normalize(df_vldvst, "PM_VECTOR_LD_CMPL (min)", "Vector Loads / Loop Iteration")
-		common.normalize(df_vldvst, "PM_VECTOR_ST_CMPL (min)", "Vector Stores / Loop Iteration")
-		df_ldst = pd.read_csv(input3, skiprows=range(2, 50000, 2))
-		common.normalize(df_ldst, "PM_LD_CMPL (min)", "Loads / Loop Iteration")
-		common.normalize(df_ldst, "PM_ST_CMPL (min)", "Stores / Loop Iteration")
-		df_byte = pd.DataFrame()
-		df_byte["Loads / Loop Iteration"] = (df_vldvst.set_index("nx")["Vector Loads / Loop Iteration"] + df_ldst.set_index("nx")["Loads / Loop Iteration"])*8
-		df_byte["Stores / Loop Iteration"] = (df_vldvst.set_index("nx")["Vector Stores / Loop Iteration"] + df_ldst.set_index("nx")["Stores / Loop Iteration"])*8
-		I_flop_scalar = df_flop.set_index("nx")["Scalar FlOps / Loop Iteration"]
-		I_flop_vector = df_flop.set_index("nx")["Vector FlOps / Loop Iteration"]
-		I_mem_load    = df_byte["Loads / Loop Iteration"]
-		I_mem_store   = df_byte["Stores / Loop Iteration"]
+		df_byte = task2b(bytes=True, just_return=True)
+		I_flop_scalar = df_flop.set_index("Grid Points")["Scalar FlOps (min)"]
+		I_flop_vector = df_flop.set_index("Grid Points")["Vector FlOps (min)"]
+		I_mem_load    = df_byte["Loads"]
+		I_mem_store   = df_byte["Stores"]
 		df_ai = pd.DataFrame()
 		df_ai["Arithmetic Intensity"] = (I_flop_scalar + I_flop_vector) / (I_mem_load + I_mem_store)
 		fig, ax = plt.subplots()