Initial plot scripts

gen_horsweep_plots.py

@@ -0,0 +1,27 @@
+from plot_utilities import create_plot, parse_input_file
+
+def create_time_plot(data, labels, output_name):
+    create_plot(data, labels, output_name, 'GTBENCH Median Runtime with 95% Confidence Intervals', 'Domain size', 'Median runtime', 'Median Time 95% Confidence Upper', 'Median Time 95% Confidence Lower', 'Domain Size (NxNx64)', 'Median Runtime')
+
+def create_columns_plot(data, labels, output_name):
+    create_plot(data, labels, output_name, 'GTBENCH Columns per Second with 95% Confidence Intervals', 'Domain size', 'Columns per Second', 'Columns per Second 95% Confidence Upper', 'Columns per Second 95% Confidence Lower', 'Domain Size (NxNx64)', 'Columns per Second')
+
+def create_elements_plot(data, labels, output_name):
+    create_plot(data, labels, output_name, 'GTBENCH Elements per Second with 95% Confidence Intervals', 'Domain size', 'Elements per Second', 'Elements per Second 95% Confidence Upper', 'Elements per Second 95% Confidence Lower', 'Domain Size (NxNx64)', 'Elements per Second')
+
+
+data = {}
+
+systems = ["GH200"]
+input_files = ["cpu_ihorswp.out", "cpu_khorswp.out"]
+labels = ["cpu_ifirst", "cpu_kfirst"]
+
+for system in systems:
+    data[system] = {}
+    for file, variant in zip(input_files, labels):
+        data[system][variant] = parse_input_file(file)
+        print(data[system][variant])
+
+create_time_plot(data, systems, "santis_time_horswp.png")
+create_columns_plot(data, systems, "santis_columns_horswp.png")
+create_elements_plot(data, systems, "santis_elements_horswp.png")

plot_utilities.py

@@ -0,0 +1,96 @@
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+import re
+import math
+
+def parse_input_file(file_path):
+    # Initialize dictionaries to store the parsed data
+    domain_data = {
+        'Domain size': [],
+        'Median runtime': [],
+        'Median Time 95% Confidence Lower': [],
+        'Median Time 95% Confidence Upper': [],
+        'Columns per Second': [],
+        'Columns per Second 95% Confidence Lower': [],
+        'Columns per Second 95% Confidence Upper': [],
+        'Elements per Second': [],
+        'Elements per Second 95% Confidence Lower': [],
+        'Elements per Second 95% Confidence Upper': []
+    }
+
+    # Read the file
+    with open(file_path, 'r') as file:
+        lines = file.readlines()
+
+    # Regular expressions to extract relevant information
+    domain_size_pattern = re.compile(r'Domain size:\s+(\d+)x(\d+)x(\d+)')
+    median_time_pattern = re.compile(r'Median time:\s+(\d+(?:\.\d+)?)s \(95% confidence: (\d+(?:\.\d+)?)s - (\d+(?:\.\d+)?)s\)')
+    cols_per_second_pattern = re.compile(r'Columns per second:\s+(\d+(?:\.\d+)?) \(95% confidence: (\d+(?:\.\d+)?) - (\d+(?:\.\d+)?)\)')
+
+    # Parsing the file content
+    current_domain_size = None
+    for line in lines:
+        domain_size_match = domain_size_pattern.search(line)
+        median_time_match = median_time_pattern.search(line)
+        cols_per_second_match = cols_per_second_pattern.search(line)
+
+        if domain_size_match:
+            current_domain_size = domain_size_match.group(1)
+        elif median_time_match and current_domain_size:
+            median_time = float(median_time_match.group(1))
+            conf_lower = float(median_time_match.group(2))
+            conf_upper = float(median_time_match.group(3))
+            domain_data['Domain size'].append(int(current_domain_size))
+            domain_data['Median runtime'].append(median_time)
+            domain_data['Median Time 95% Confidence Lower'].append(conf_lower)
+            domain_data['Median Time 95% Confidence Upper'].append(conf_upper)
+        elif cols_per_second_match and current_domain_size:
+            cols_per_second = float(cols_per_second_match.group(1))
+            conf_lower = float(cols_per_second_match.group(2))
+            conf_upper = float(cols_per_second_match.group(3))
+            domain_data['Columns per Second'].append(cols_per_second)
+            domain_data['Columns per Second 95% Confidence Lower'].append(conf_lower)
+            domain_data['Columns per Second 95% Confidence Upper'].append(conf_upper)
+            domain_data['Elements per Second'].append(cols_per_second/int(current_domain_size))
+            domain_data['Elements per Second 95% Confidence Lower'].append(conf_lower/int(current_domain_size))
+            domain_data['Elements per Second 95% Confidence Upper'].append(conf_upper/int(current_domain_size))
+
+    return domain_data
+
+def create_plot(data, labels, output_name, title, x_key, y_key, upper_key, lower_key, xlabel, ylabel, xscale='linear', yscale='linear'):
+    min_x = 0
+    max_x = 0
+    # Plotting with for loop
+    plt.figure(figsize=(10, 6))
+    for idx, (cpu, cpu_data) in enumerate(data.items()):
+        for idx2, (key, value) in enumerate(cpu_data.items()):
+            df = pd.DataFrame(value)
+            min_x = min(df[x_key])
+            max_x = max(df[x_key])
+            sns.lineplot(data=df, x=x_key, y=y_key, marker='o', label=labels[idx] + ' ' + key)
+            plt.errorbar(df[x_key], df[y_key], yerr=[df[y_key] - df[lower_key], df[upper_key] - df[y_key]], fmt='o', capsize=5)
+
+    # Setting labels and title
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    plt.title(title)
+
+    # Setting the scale to linear for the y-axis
+    plt.yscale(yscale)
+
+    # Displaying the plot
+    plt.xscale(xscale)
+
+    # plt.xticks([16, 32, 64, 128, 256, 512, 1024], rotation=0, fontsize=7)
+    # Dynamically determining the range of xticks
+    min_pow = math.floor(math.log2(min_x))
+    max_pow = math.ceil(math.log2(max_x))
+    xticks = [2 ** i for i in range(min_pow, max_pow + 1)]
+    plt.xticks(xticks)
+
+    plt.grid(True)
+    plt.legend()
+    # plt.show()
+    plt.savefig(output_name, dpi=300)
+