ci: update workflows

Author: AKonnyaku

.github/scripts/benchmark_formatter.py

@@ -0,0 +1,169 @@
+import pathlib, re, sys
+
+try:
+    p = pathlib.Path("comparison.md")
+    if not p.exists():
+        print("comparison.md not found, skipping post-processing.")
+        sys.exit(0)
+
+    lines = p.read_text(encoding="utf-8").splitlines()
+    processed_lines = []
+    in_code = False
+
+    def strip_worker_suffix(text: str) -> str:
+        # Also strip "Benchmark" prefix if it somehow sneaked in
+        text = re.sub(r"^Benchmark", "", text)
+        return re.sub(r"(\S+?)-\d+(\s|$)", r"\1\2", text)
+
+    def get_icon(diff_val: float) -> str:
+        if diff_val > 10:
+            return "🐌"
+        if diff_val < -10:
+            return "🚀"
+        return "➡️"
+
+    def clean_superscripts(text: str) -> str:
+        return re.sub(r"[¹²³⁴⁵⁶⁷⁸⁹⁰]", "", text)
+
+    def parse_val(token: str):
+        if "%" in token or "=" in token:
+            return None
+        token = clean_superscripts(token)
+        token = token.split("±")[0].strip()
+        token = token.split("(")[0].strip()
+        if not token:
+            return None
+
+        m = re.match(r"^([-+]?\d*\.?\d+)([a-zA-Zµ]+)?$", token)
+        if not m:
+            return None
+        try:
+            val = float(m.group(1))
+        except ValueError:
+            return None
+        suffix = (m.group(2) or "").replace("µ", "u")
+        
+        if suffix in ["n", "ns"]: return val * 1e-9
+        if suffix in ["u", "us"]: return val * 1e-6
+        if suffix in ["m", "ms"]: return val * 1e-3
+        if suffix == "s": return val
+        if suffix == "": return val # Handle unitless numbers (e.g. counts) if any
+        
+        # If we reach here, it's an unexpected unit
+        raise ValueError(f"Unexpected unit: {suffix}")
+
+    def extract_two_numbers(tokens):
+        found = []
+        for t in tokens[1:]:  # skip name
+            if t in {"±", "∞", "~", "│", "|"}:
+                continue
+            if "%" in t or "=" in t:
+                continue
+            # Skip p=... n=...
+            if t.startswith("p=") or t.startswith("n="):
+                continue
+                
+            val = parse_val(t)
+            if val is not None:
+                found.append(val)
+                if len(found) == 2:
+                    break
+        return found
+
+    # Pass 0: Calculate widths
+    max_content_width = 0
+
+    for line in lines:
+        if line.strip().startswith("```"):
+            in_code = not in_code
+            continue
+        if not in_code:
+            continue
+
+        if re.match(r"^\s*[¹²³⁴⁵⁶⁷⁸⁹⁰]", line) or re.search(r"need\s*>?=\s*\d+\s+samples", line):
+            continue
+        if not line.strip() or line.strip().startswith(("goos:", "goarch:", "pkg:", "cpu:")):
+            continue
+        if "│" in line and ("vs base" in line or "old" in line or "new" in line):
+            continue
+
+        curr_line = strip_worker_suffix(line).rstrip()
+        w = len(curr_line)
+        if w > max_content_width:
+            max_content_width = w
+
+    diff_col_start = max_content_width - 13
+    # User asked to shift first column by 8 chars. 
+    # This means the whole table shifts right? Or just the text inside?
+    # I'll prepend 8 spaces to the final output line.
+    INDENT = "        "
+
+    for line in lines:
+        if line.strip().startswith("```"):
+            in_code = not in_code
+            processed_lines.append(line)
+            continue
+
+        if not in_code:
+            processed_lines.append(line)
+            continue
+
+        # Footnotes
+        if re.match(r"^\s*[¹²³⁴⁵⁶⁷⁸⁹⁰]", line) or re.search(r"need\s*>?=\s*\d+\s+samples", line):
+            processed_lines.append(INDENT + line)
+            continue
+
+        # Header
+        if "│" in line and ("vs base" in line or "old" in line or "new" in line):
+            stripped_header = line.rstrip().rstrip("│").rstrip()
+            stripped_header = re.sub(r"\s+Diff\s*$", "", stripped_header, flags=re.IGNORECASE)
+            
+            if len(stripped_header) < diff_col_start:
+                new_header = stripped_header + " " * (diff_col_start - len(stripped_header))
+            else:
+                new_header = stripped_header + "  "
+            
+            if "vs base" in line:
+                new_header += "Diff"
+            
+            new_header += "│"
+            processed_lines.append(INDENT + new_header)
+            continue
+
+        # Metadata
+        if not line.strip() or line.strip().startswith(("goos:", "goarch:", "pkg:", "cpu:")):
+            processed_lines.append(INDENT + line)
+            continue
+
+        # Data Lines
+        line = strip_worker_suffix(line)
+        tokens = line.split()
+        if not tokens:
+            processed_lines.append(INDENT + line)
+            continue
+
+        numbers = extract_two_numbers(tokens)
+        
+        def append_aligned(left_part, content):
+            if len(left_part) < diff_col_start:
+                aligned = left_part + " " * (diff_col_start - len(left_part))
+            else:
+                aligned = left_part + "  "
+            return f"{INDENT}{aligned}{content}"
+
+        # Geomean
+        
+        if len(numbers) == 2 and numbers[0] != 0:
+            diff_val = (numbers[1] - numbers[0]) / numbers[0] * 100
+            icon = get_icon(diff_val)
+            left = line.rstrip()
+            processed_lines.append(append_aligned(left, f"{diff_val:+.2f}% {icon}"))
+            continue
+            
+        processed_lines.append(INDENT + line)
+
+    p.write_text("\n".join(processed_lines) + "\n", encoding="utf-8")
+
+except Exception as e:
+    print(f"Error post-processing comparison.md: {e}")
+    sys.exit(1)

.github/scripts/benchstat_simulator.py

@@ -0,0 +1,119 @@
+import json
+import sys
+import math
+import re
+import platform
+import subprocess
+
+# Force UTF-8 output
+sys.stdout.reconfigure(encoding="utf-8")
+
+def load_json(path):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading {path}: {e}", file=sys.stderr)
+        return None
+
+def format_val(val):
+    if val is None:
+        return "N/A"
+    # val is in ns
+    if val < 1e3:
+        return f"{val:.2f}n" # ns
+    if val < 1e6:
+        return f"{val/1e3:.2f}µ" # us
+    if val < 1e9:
+        return f"{val/1e6:.2f}m" # ms
+    return f"{val/1e9:.2f}s" # s
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: python benchstat_simulator.py base.json pr.json")
+        sys.exit(1)
+
+    base_data = load_json(sys.argv[1])
+    pr_data = load_json(sys.argv[2])
+
+    if not base_data or not pr_data:
+        sys.exit(1)
+
+    base_map = {b["name"]: b["value"] for b in base_data.get("benches", [])}
+    pr_map = {b["name"]: b["value"] for b in pr_data.get("benches", [])}
+
+    all_names = sorted(set(base_map.keys()) | set(pr_map.keys()))
+
+    print("Comparison:")
+    print("```")
+    print("goos: linux")
+    print("goarch: amd64")
+    print("pkg: github.com/casbin/node-casbin")
+    
+    cpu_info = "GitHub Actions Runner"
+    try:
+        if platform.system() == "Windows":
+             cpu_info = platform.processor()
+        elif platform.system() == "Linux":
+            try:
+                # Try lscpu first
+                command = "lscpu"
+                output = subprocess.check_output(command, shell=True).decode()
+                for line in output.splitlines():
+                    if "Model name" in line:
+                        cpu_info = line.split(":")[1].strip()
+                        break
+            except:
+                # Fallback to /proc/cpuinfo
+                with open("/proc/cpuinfo", "r") as f:
+                    for line in f:
+                        if "model name" in line:
+                            cpu_info = line.split(":")[1].strip()
+                            break
+    except:
+        pass
+    print(f"cpu: {cpu_info}")
+    
+    # Reduced padding: 52 instead of 50
+    # Header
+    print(f"{'':<52}│ {'base':<19} │           {'pr':<19}           │")
+    print(f"{'':<52}│       sec/op        │    sec/op      vs base                │   Diff")
+
+    base_values = []
+    pr_values = []
+
+    for name in all_names:
+        base_val = base_map.get(name, 0)
+        pr_val = pr_map.get(name, 0)
+
+        if base_val > 0: base_values.append(base_val)
+        if pr_val > 0: pr_values.append(pr_val)
+
+        def format_cell(val):
+            if val == 0: return "N/A"
+            return f"{format_val(val)} ± ∞ ¹"
+
+        base_str = format_cell(base_val)
+        pr_str = format_cell(pr_val)
+
+        comp_str = ""
+        if base_val > 0 and pr_val > 0:
+            comp_str = "~ (p=1.000 n=1) ²"
+        
+        print(f"{name:<52}{base_str:<22}{pr_str:<22}{comp_str}")
+
+    if base_values and pr_values:
+        def calc_geo(vals):
+            return math.exp(sum(math.log(x) for x in vals) / len(vals))
+        g_base = calc_geo(base_values)
+        g_pr = calc_geo(pr_values)
+        print(f"{'geomean':<52}{format_val(g_base):<22}{format_val(g_pr):<22}")
+
+    print("¹ need >= 6 samples for confidence interval at level 0.95")
+    print("² all samples are equal")
+    print("³ need >= 4 samples to detect a difference at alpha level 0.05")
+    print("⁴ summaries must be >0 to compute geomean")
+    print("```")
+
+if __name__ == "__main__":
+    main()

.github/scripts/download_artifact.js

@@ -0,0 +1,33 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+module.exports = async ({ github, context, core }) => {
+  try {
+    const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      run_id: context.payload.workflow_run.id,
+    });
+
+    const matchArtifact = artifacts.data.artifacts.find((artifact) => {
+      return artifact.name === 'benchmark-results';
+    });
+
+    if (!matchArtifact) {
+      core.setFailed("No artifact named 'benchmark-results' found.");
+      return;
+    }
+
+    const download = await github.rest.actions.downloadArtifact({
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      artifact_id: matchArtifact.id,
+      archive_format: 'zip',
+    });
+
+    const fs = require('fs');
+    const path = require('path');
+    const workspace = process.env.GITHUB_WORKSPACE;
+    fs.writeFileSync(path.join(workspace, 'benchmark-results.zip'), Buffer.from(download.data));
+  } catch (error) {
+    core.setFailed(`Failed to download artifact: ${error.message}`);
+  }
+};