predictiveModel.py

# ------------------------------------------------------------
# GPU Model (Measured from Microbenchmarks)
# ------------------------------------------------------------
class GPUModel:
    def __init__(self):
        # All units converted to seconds / bytes
        self.effFLOPS    = 151.7e9     # 151.7 GFLOP/s
        self.effDRAM_BW  = 9.68e9      # 9.68 GB/s
        self.PCIELat     = 42.5e-6     # 42.5 µs
        self.effPCIE_BW  = 5.72e9      # 5.72 GB/s
        self.syncBlkLat  = 73e-9       # 73 ns
        self.synInterLat = 9.17e-6     # 9.17 µs

# ------------------------------------------------------------
# Kernel Model (per iteration)
# ------------------------------------------------------------
class KernelModel:
    def __init__(self, flops_per_iter, bytes_per_iter,
                 sync_threadcalls=0, sync_multigpu=0):

        self.flops_per_iter            = flops_per_iter
        self.bytes_per_iter            = bytes_per_iter
        self.sync_threadCalls_per_iter = sync_threadcalls
        self.sync_InterCall_per_iter   = sync_multigpu

# ------------------------------------------------------------
# Component Models
# ------------------------------------------------------------
def compute_time(N, kernel, gpu):
    totalFLOPS = kernel.flops_per_iter * N
    return totalFLOPS / gpu.effFLOPS

def memory_time(N, kernel, gpu):
    totalBytes = kernel.bytes_per_iter * N
    return totalBytes / gpu.effDRAM_BW

def computetransfer_time(N, gpu, kernel):
    totalBytes = kernel.bytes_per_iter * N
    return totalBytes / gpu.effPCIE_BW

def computecomm_time(N, kernel, gpu):
    Tlat  = gpu.PCIELat
    Tdata = computetransfer_time(N, gpu, kernel)
    return Tlat + Tdata

def computesyncblk_time(N, kernel, gpu):
    return kernel.sync_threadCalls_per_iter * N * gpu.syncBlkLat

def computesyncinter_time(N, kernel, gpu):
    return kernel.sync_InterCall_per_iter * N * gpu.synInterLat

def computesync_time(N, kernel, gpu):
    return computesyncblk_time(N, kernel, gpu) + \
           computesyncinter_time(N, kernel, gpu)

# ------------------------------------------------------------
# Total Runtime
# ------------------------------------------------------------
def getTime_1GPU(N, kernel, gpu):
    return (
        compute_time(N, kernel, gpu) +
        memory_time(N, kernel, gpu) +
        computesync_time(N, kernel, gpu)
    )

def getTime_2GPU(N, kernel, gpu):
    N2 = N / 2
    return (
        compute_time(N2, kernel, gpu) +
        memory_time(N2, kernel, gpu) +
        computesync_time(N, kernel, gpu) +
        computecomm_time(N2, kernel, gpu)
    )

# ------------------------------------------------------------
# Load CSVs
# ------------------------------------------------------------
df_nbody   = pd.read_csv("./Data/NOBDY-GPU-data.csv")
df_cg      = pd.read_csv("./Data/CG-GPU-data.csv")
df_stencil = pd.read_csv("./Data/Stencil-GPU-data.csv")
df_D2D     = pd.read_csv("./Data/D2D-GPU-data.csv")


df_nbody_avg   = df_nbody.groupby(["Bodies","Iters","Type"]).mean().reset_index()
df_cg_avg      = df_cg.groupby(["Lengths","Iters","Type"]).mean().reset_index()
df_stencil_avg = df_stencil.groupby(["GridSize","Iters","Type"]).mean().reset_index()
df_D2D_avg     = df_D2D.groupby(["Lengths","Iters","Type"]).mean().reset_index()

# ------------------------------------------------------------
# Kernel Models (YOU WILL FIX THESE LATER)
# ------------------------------------------------------------
gpuTitan = GPUModel()

kernelNBODY   = KernelModel(27, 16)
kernelCG      = KernelModel(15, 60)
kernelSTENCIL = KernelModel(4, 20)
kernelD2D     = KernelModel(10, 32)

# ------------------------------------------------------------
# Plot Function (now includes N_model mapping)
# ------------------------------------------------------------
def plot_benchmark(name, df, size_col, kernel):

    Ns = sorted(df[size_col].unique())

    measured_1, measured_2 = [], []
    predicted_1, predicted_2 = [], []
    speed_meas, speed_pred = [], []

    for N in Ns:
        dfN = df[df[size_col] == N]
        iters = dfN["Iters"].iloc[0]

        if name == "N-Body":
            N_model = N * N
        elif name == "2D Stencil":
            N_model = N * N
        elif name == "Conjugate Gradient":
            N_model = N * N
        elif name == "D2D":
            N_model = N * N
        else:
            N_model = N

        t1_meas = dfN[dfN["Type"]=="Single"]["Time"].iloc[0]
        t2_meas = dfN[dfN["Type"]=="Multi"]["Time"].iloc[0]

        measured_1.append(t1_meas)
        measured_2.append(t2_meas)

        t1_pred = getTime_1GPU(N_model, kernel, gpuTitan) * iters
        t2_pred = getTime_2GPU(N_model, kernel, gpuTitan) * iters

        predicted_1.append(t1_pred)
        predicted_2.append(t2_pred)

        speed_meas.append(t1_meas / t2_meas)
        speed_pred.append(t1_pred / t2_pred)

    fig, ax = plt.subplots()
    ax.set(
        xlabel="Problem Size",
        ylabel="Speedup T1/T2",
        title=f"{name}: Speedup (Measured vs Predicted)",
        ylim=(0,5)
    )
    ax.semilogx(Ns, speed_meas, 'o-', label="Measured")
    ax.semilogx(Ns, speed_pred, 'x--', label="Predicted")
    ax.grid(True)
    ax.legend(loc='best')
    plt.tight_layout()
    fig.savefig("./Plots/"+f"fig_{name.replace(' ','_')}_speedup.png", dpi=300)


# ------------------------------------------------------------
# Plot: Bar graph of measured speedup + line plot of predicted
# ------------------------------------------------------------
def plot_single_iteration_speedup(name, df, size_col, kernel, chosen_iter):

    # Filter data for this iteration
    df_iter = df[df["Iters"] == chosen_iter]
    if df_iter.empty:
        print(f"[WARNING] No data for iteration {chosen_iter} in {name}")
        return

    # Extract measured single/multi
    singles = df_iter[df_iter["Type"]=="Single"].sort_values(size_col)
    multis  = df_iter[df_iter["Type"]=="Multi"].sort_values(size_col)

    # Merge
    merged = pd.merge(
        singles,
        multis,
        on=[size_col, "Iters"],
        suffixes=("_single", "_multi")
    )

    # Compute measured speedup
    merged["Speedup_measured"] = merged["Time_single"] / merged["Time_multi"]

    # Compute predicted speedup:
    Ns = merged[size_col].values
    measured_s = merged["Time_single"].values
    measured_m = merged["Time_multi"].values

    predicted_speedups = []
    for N in Ns:

        # Map problem size to N_model
        if name == "N-Body":
            N_model = N * N
        elif name == "2D Stencil":
            N_model = N * N
        elif name == "Conjugate Gradient":
            N_model = N * N
        elif name == "D2D":
            N_model = N * N
        else:
            N_model = N

        t1_pred = getTime_1GPU(N_model, kernel, gpuTitan) * chosen_iter
        t2_pred = getTime_2GPU(N_model, kernel, gpuTitan) * chosen_iter

        predicted_speedups.append(t1_pred / t2_pred)

    # -------- Plot --------
    fig, ax = plt.subplots()

    # BAR GRAPH (Measured)
    ax.bar(
        [str(int(x)) for x in Ns],
        merged["Speedup_measured"],
        color='tab:blue',
        alpha=0.7,
        label=f"Measured Speedup ({chosen_iter} iters)"
    )

    # LINE PLOT (Predicted)
    ax.plot(
        [str(int(x)) for x in Ns],
        predicted_speedups,
        marker='o',
        linestyle='--',
        color='tab:red',
        label="Predicted Speedup"
    )

    ax.set_xlabel("Problem Size")
    ax.set_ylabel("Speedup (T1 / T2)")
    ax.set_title(f"{name}: Measured vs Predicted Speedup (Iteration {chosen_iter})")
    ax.grid(True)
    ax.legend()

    plt.tight_layout()
    fig.savefig(f"./Plots/fig_{name.replace(' ','_')}_bar_speedup_iter{chosen_iter}.png",
                dpi=300)


# ------------------------------------------------------------
# Run All Benchmarks
# ------------------------------------------------------------
# User chooses the iteration they want to highlight
chosen_iter = 50   # <-- change this whenever you want

plot_single_iteration_speedup("N-Body",             df_nbody_avg,   "Bodies",   kernelNBODY,   chosen_iter)
plot_single_iteration_speedup("Conjugate Gradient", df_cg_avg,      "Lengths",  kernelCG,      chosen_iter)
plot_single_iteration_speedup("2D Stencil",         df_stencil_avg, "GridSize", kernelSTENCIL, chosen_iter)
plot_single_iteration_speedup("D2D",                df_D2D_avg,     "Lengths",  kernelD2D,     chosen_iter)