add script to create tables for different flags

Author: jaja360

.gitignore

@@ -1,5 +1,8 @@
 build
 build_debug
 build_script
+outputs
+tags
 compile_commands.json
 .cache
+**/__pycache__

scripts/generate_multiple_tables.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+import subprocess
+import os
+import platform
+from latex_table import generate_latex_table
+
+# Configuration
+benchmark_executable = './build/benchmarks/benchmark'
+latex_script = './scripts/latex_table.py'
+output_dir = './outputs'
+input_files = [
+    'data/canada.txt',
+    'data/mesh.txt',
+]
+models = [
+    'uniform_01',
+    'uniform_all',
+    'integer_uniform',
+    'centered',
+    'non_centered',
+]
+runs_r = 1_000
+volume_v = 1_000_000
+flag_combinations = [
+    [],
+    ['-F6'],
+    ['-s'],
+    ['-F6', '-s'],
+]
+
+
+def get_cpu_model():
+    if platform.system() == "Windows":
+        return platform.processor()
+    elif platform.system() == "Darwin":
+        os.environ['PATH'] = os.environ['PATH'] + os.pathsep + '/usr/sbin'
+        command = "sysctl -n machdep.cpu.brand_string"
+        return subprocess.check_output(command).strip()
+    elif platform.system() == "Linux":
+        command = "cat /proc/cpuinfo"
+        output = subprocess.check_output(command, shell=True).decode().strip()
+        for line in output.split("\n"):
+            if line.startswith("model name"):
+                return line.split(':', 1)[1].strip()
+    return "unknown_cpu"
+
+
+CPUModel = get_cpu_model().replace(' ', '_').replace('/', '-').replace('@', '')
+os.makedirs(output_dir, exist_ok=True)
+
+
+# Helper to run a command and return its stdout
+def run_cmd(cmd):
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    result.check_returncode()
+    return result.stdout
+
+
+# Process a single benchmark invocation and generate .tex
+def process_job(label, cmd_args, flags):
+    # Run the benchmark
+    cmd = [benchmark_executable] + cmd_args + flags
+    print(f"Running: {' '.join(cmd)}")
+    output = run_cmd(cmd)
+
+    # Build output file name
+    flag_label = ''.join([f.strip('-') for f in flags]) or 'none'
+    safe_label = label.replace('.', '_')
+    filename = f"{CPUModel}_{safe_label}_{flag_label}.tex"
+    out_path = os.path.join(output_dir, filename)
+
+    # Write to file
+    tex_content = generate_latex_table(output)
+    with open(out_path, 'w') as f:
+        f.write(tex_content)
+    print(f"Written: {out_path}\n")
+
+
+if __name__ == '__main__':
+    # File-based benchmarks
+    for filepath in input_files:
+        file_label = os.path.splitext(os.path.basename(filepath))[0]
+        for flags in flag_combinations:
+            process_job(
+                label=file_label,
+                cmd_args=['-f', filepath, '-r', str(runs_r)],
+                flags=flags
+            )
+
+    # Model-based benchmarks
+    for model in models:
+        for flags in flag_combinations:
+            process_job(
+                label=model,
+                cmd_args=['-m', model, '-v', str(volume_v), '-r', str(runs_r)],
+                flags=flags
+            )

scripts/latex_table.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
-
 import sys
 import re
 import argparse
 
+
 # Function to format a number to two significant digits
 def format_to_two_sig_digits(value):
     if not isinstance(value, (int, float)) or value == 0:
         return "N/A"
-    
+
     # Handle negative numbers
     is_negative = value < 0
     abs_value = abs(value)
@@ -27,14 +27,15 @@ def format_to_two_sig_digits(value):
 
     # Format the number
     if exponent >= 0 and exponent <= 4:
-        format = f"{'-' if is_negative else ''}{abs_value*10**exponent}"
+        format = f"{'-' if is_negative else ''}{abs_value * 10 ** exponent}"
         format = format.replace(".0", "")
         return format
     elif exponent < 0 and exponent >= -4:
-        return f"{'-' if is_negative else ''}{abs_value*10**exponent:.1f}"
+        return f"{'-' if is_negative else ''}{abs_value * 10 ** exponent:.1f}"
     else:
         return f"{'-' if is_negative else ''}{abs_value:.1f}e{exponent}"
 
+
 # Function to parse the raw input data
 def parse_input(data):
     lines = data.splitlines()
@@ -54,6 +55,7 @@ def parse_input(data):
             parsed_data.append(current_entry)
         if not current_entry:
             continue
+
         # Match lines with ns/f
         match_ns = re.search(r"([\d.]+)\s*ns/f", line)
         if match_ns and current_entry:
@@ -72,27 +74,29 @@ def parse_input(data):
     # Filter out incomplete entries
     return parsed_data
 
+
 # Function to generate LaTeX table
-def generate_latex_table(data):
+def generate_latex_table(raw_input):
+    data = parse_input(raw_input)
+
     latex_table = r"""
 \begin{tabular}{lccc}
 \toprule
 \textbf{Name} & \textbf{ns/f} & \textbf{instructions/float} & \textbf{instructions/cycle} \\
 \midrule
 """
-
     for entry in data:
         name = entry["name"].replace("_", "\\_")  # Escape underscores for LaTeX
         ns_per_float = format_to_two_sig_digits(entry['ns_per_float']) if 'ns_per_float' in entry else 'N/A'
         inst_per_float = format_to_two_sig_digits(entry['inst_per_float']) if 'inst_per_float' in entry else 'N/A'
         inst_per_cycle = format_to_two_sig_digits(entry['inst_per_cycle']) if 'inst_per_cycle' in entry else 'N/A'
         latex_table += f"{name} & {ns_per_float} & {inst_per_float} & {inst_per_cycle} \\\\ \n"
-
     latex_table += r"""\bottomrule
 \end{tabular}
 """
     return latex_table
 
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Generate LaTeX table from performance data")
     parser.add_argument("file", nargs="?", help="Optional input file name (if not provided, reads from stdin)")
@@ -111,6 +115,6 @@ def generate_latex_table(data):
             sys.exit(1)
     else:
         raw_input = sys.stdin.read()
-    parsed_data = parse_input(raw_input)
-    latex_output = generate_latex_table(parsed_data)
-    print(latex_output)
+
+    latex_output = generate_latex_table(raw_input)
+    print(latex_output)