gh-NNNN: Add float-to-string benchmarks comparing Ryu vs Gay's dtoa

bench_ryu.py: benchmark script covering all float formatting code paths:
  - repr/str (shortest round-trip, mode 0)
  - %e / f'{x:.Ne}' (exponential format, mode 2)
  - %f / f'{x:.Nf}' (fixed-point format, mode 3)
  - %g / f'{x:.Ng}' (general format, mode 2)
  - f-string variants (f'{x!r}', f'{x}', f'{x:.3f}', f'{x:.6g}')
  - float.__round__(x, k) for k >= 0 and k < 0

bench_ryu_compare.py: comparison script that reads JSON output from
bench_ryu.py and prints a speedup table.

Results on Windows/x64 (MSC, typical values):
  Geomean speedup: ~1.7x
  Best case: f'{x:.3f}' → 5.5x faster
  repr/str: ~1.5x faster
  %g format: ~1.4x faster
  %e format: ~0.85x (slight regression, Ryu overhead in d2exp parsing)
  round(x, k>=0): ~2.5x faster

Author: eendebakpt

bench_ryu.py

@@ -0,0 +1,154 @@
+"""
+bench_ryu.py - Benchmark float-to-string conversion: Ryu vs Gay's dtoa
+
+Usage:
+    python bench_ryu.py          # run all benchmarks, print table
+    python bench_ryu.py --json   # emit JSON for comparison scripts
+
+Cases covered:
+  repr / str      - shortest round-trip (mode 0, d2s)
+  %e format       - exponential N-significant-digit (mode 2, d2exp)
+  %f format       - fixed-point N-past-decimal (mode 3, d2fixed)
+  %g format       - general (mode 2, d2exp)
+  f-string        - f'{x:.3f}', f'{x:.6g}', f'{x!r}'
+  float.__round__ - round(x, k) for k >= 0 and k < 0
+"""
+
+import timeit
+import json
+import sys
+import math
+
+# ---------------------------------------------------------------------------
+# Test values
+# ---------------------------------------------------------------------------
+
+SMALL_INTS   = [float(n) for n in range(1, 21)]
+FRACTIONS    = [1.1, 1.23456789, 0.1, 0.001, 1/3, math.pi, math.e]
+LARGE        = [1e100, 1.23456789e200, 9.9e307]
+SUBNORMALS   = [5e-324, 2.2e-308, 1e-310]
+SPECIALS     = [float('inf'), float('-inf'), float('nan')]
+NEGATIVES    = [-1.5, -0.1, -math.pi]
+MIX          = SMALL_INTS + FRACTIONS + LARGE + SUBNORMALS + NEGATIVES
+
+
+def _make_list(values, n=1000):
+    """Repeat values to fill a list of length n."""
+    base = values * (n // len(values) + 1)
+    return base[:n]
+
+
+# ---------------------------------------------------------------------------
+# Benchmark cases  (name, stmt, setup)
+# ---------------------------------------------------------------------------
+
+def _build_cases():
+    cases = []
+
+    def add(name, stmt, values=None):
+        if values is None:
+            values = MIX
+        lst = _make_list(values)
+        # Use struct.unpack to reconstruct floats reliably (avoids inf/nan literal issues)
+        import struct
+        packed = struct.pack(f"{len(lst)}d", *lst)
+        setup = (
+            f"import struct; "
+            f"data = list(struct.unpack('{len(lst)}d', {packed!r}))"
+        )
+        cases.append((name, stmt, setup))
+
+    # repr / str – mode 0
+    add("repr(x)  [shortest]",
+        "for x in data: repr(x)")
+    add("str(x)   [shortest]",
+        "for x in data: str(x)")
+
+    # %e – mode 2, exponential
+    add("'%.6e' % x",
+        "for x in data: '%.6e' % x")
+    add("'%.2e' % x",
+        "for x in data: '%.2e' % x",
+        values=FRACTIONS + LARGE)
+
+    # %f – mode 3
+    add("'%.3f' % x",
+        "for x in data: '%.3f' % x")
+    add("'%.6f' % x",
+        "for x in data: '%.6f' % x")
+    add("'%.10f' % x",
+        "for x in data: '%.10f' % x",
+        values=FRACTIONS)
+
+    # %g – mode 2 (general)
+    add("'%g' % x",
+        "for x in data: '%g' % x")
+    add("'%.4g' % x",
+        "for x in data: '%.4g' % x")
+
+    # f-strings (go through the same code paths as % formatting)
+    add("f'{x:.3f}'",
+        "for x in data: f'{x:.3f}'")
+    add("f'{x:.6g}'",
+        "for x in data: f'{x:.6g}'")
+    add("f'{x!r}'",
+        "for x in data: f'{x!r}'")
+    add("f'{x}'",
+        "for x in data: f'{x}'")
+
+    # float.__round__ ndigits >= 0 – mode 3 via Ryu
+    add("round(x, 2)",
+        "for x in data: round(x, 2)")
+    add("round(x, 6)",
+        "for x in data: round(x, 6)")
+
+    # float.__round__ ndigits < 0 – still uses Gay's dtoa
+    add("round(x, -2)  [Gay fallback]",
+        "for x in data: round(x, -2)",
+        values=LARGE + SMALL_INTS)
+
+    # specials (inf/nan) – mode 0
+    add("repr(inf/nan)",
+        "for x in data: repr(x)",
+        values=SPECIALS * 10)
+
+    return cases
+
+
+# ---------------------------------------------------------------------------
+# Run benchmark
+# ---------------------------------------------------------------------------
+
+def run_benchmarks(number=500, repeat=7):
+    cases = _build_cases()
+    results = {}
+
+    print(f"Python {sys.version}")
+    print(f"{'Case':<35}  {'ns/op':>8}  {'min ms':>8}")
+    print("-" * 60)
+
+    for name, stmt, setup in cases:
+        times = timeit.repeat(stmt, setup=setup, number=number, repeat=repeat)
+        # timeit returns total time for `number` iterations
+        # We want per-operation time in ns
+        best_total = min(times)           # seconds for `number` iters
+        # Each iteration processes 1000 items (len of data list)
+        n_items = 1000
+        ns_per_op = best_total / number / n_items * 1e9
+        ms_total  = best_total * 1000
+        print(f"  {name:<33}  {ns_per_op:8.1f}  {ms_total:8.1f}")
+        results[name] = {"ns_per_op": ns_per_op, "min_ms": ms_total}
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# main
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    emit_json = "--json" in sys.argv
+    results = run_benchmarks()
+    if emit_json:
+        label = sys.argv[sys.argv.index("--label") + 1] if "--label" in sys.argv else "unknown"
+        print("\n" + json.dumps({"label": label, "results": results}))

bench_ryu_compare.py

@@ -0,0 +1,77 @@
+"""
+bench_ryu_compare.py - Compare two bench_ryu.py JSON output files.
+
+Usage:
+    python bench_ryu_compare.py bench_main_result.txt bench_ryu_result.txt
+"""
+
+import json
+import sys
+import re
+
+
+def parse_result_file(path):
+    """Extract the JSON blob from a bench_ryu.py output file."""
+    with open(path, encoding="utf-8") as f:
+        content = f.read()
+    # Find the last JSON line
+    for line in reversed(content.splitlines()):
+        line = line.strip()
+        if line.startswith("{"):
+            return json.loads(line)
+    raise ValueError(f"No JSON found in {path}")
+
+
+def compare(baseline_path, new_path):
+    base = parse_result_file(baseline_path)
+    new  = parse_result_file(new_path)
+
+    base_label = base["label"]
+    new_label  = new["label"]
+
+    base_res = base["results"]
+    new_res  = new["results"]
+
+    all_keys = list(base_res.keys())
+
+    col_case = 35
+    print(f"\n{'Float-to-string benchmark: ' + new_label + ' vs ' + base_label}")
+    print(f"{'(lower ns/op is better, speedup > 1.0x means faster)'}")
+    print()
+    hdr = (f"{'Case':<{col_case}} "
+           f"{'base (ns)':>10}  {'new (ns)':>10}  {'speedup':>8}")
+    print(hdr)
+    print("-" * len(hdr))
+
+    speedups = []
+    for key in all_keys:
+        b = base_res[key]["ns_per_op"]
+        n = new_res.get(key, {}).get("ns_per_op")
+        if n is None:
+            print(f"  {key:<{col_case}}  {'N/A':>10}  {'N/A':>10}  {'?':>8}")
+            continue
+        speedup = b / n
+        speedups.append((key, speedup))
+        marker = "  **" if speedup > 1.5 else ("  *" if speedup > 1.1 else "")
+        print(f"  {key:<{col_case}}  {b:10.1f}  {n:10.1f}  {speedup:7.2f}x{marker}")
+
+    print()
+    if speedups:
+        geo = 1.0
+        for _, s in speedups:
+            geo *= s
+        geo **= (1 / len(speedups))
+        best = max(speedups, key=lambda x: x[1])
+        worst = min(speedups, key=lambda x: x[1])
+        print(f"  Geomean speedup : {geo:.2f}x")
+        print(f"  Best speedup    : {best[1]:.2f}x  ({best[0]})")
+        print(f"  Worst speedup   : {worst[1]:.2f}x  ({worst[0]})")
+    print()
+    print("  * >1.10x faster   ** >1.50x faster")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print(f"Usage: python {sys.argv[0]} <baseline_file> <new_file>")
+        sys.exit(1)
+    compare(sys.argv[1], sys.argv[2])