tricu

reducer_comparison.py (4413B)

---

 #!/usr/bin/env python3
 """Paired Haskell/Zig runtime measurements with complete-result checks."""
 import hashlib
 import json
 import os
 from pathlib import Path
 import platform
 import statistics
 import sys
 import time
 from process_rss import run_guarded
 
 haskell, zig, fixtures, output = sys.argv[1:]
 fixtures = Path(fixtures)
 affinity = sorted(os.sched_getaffinity(0))
 os.sched_setaffinity(0, {affinity[0]})
 cases = [(kind, n, 20) for kind in ('id', 'append') for n in (256, 4096, 16384)]
 cases += [(kind, n, 5) for kind in ('deep', 'distribution') for n in (1000, 10000, 100000)]
 cases += [('append', 4096, 256)]
 report = dict(
     complete=False, platform=platform.platform(), machine=platform.machine(),
     cpu_model=next(line.split(':', 1)[1].strip() for line in Path('/proc/cpuinfo').read_text().splitlines() if line.startswith('model name')),
     pinned_cpu=affinity[0], original_affinity=affinity, samples_per_host_case=5,
     haskell_compiler=(Path(haskell).resolve().parents[1]/'compiler-version').read_text().strip(),
     fixture_sha256={name: hashlib.sha256((fixtures/name).read_bytes()).hexdigest() for name in ('id.arboricx', 'append.arboricx')},
     runners={host: dict(path=path, sha256=hashlib.sha256(Path(path).read_bytes()).hexdigest()) for host,path in [('haskell',haskell),('zig',zig)]},
     limits=dict(rss_mib=512, wall_seconds=65, cpu_seconds=60, native_stack_mib=8,
                 haskell_rts=['-N1','-M512m','-K8m'], zig_address_space_mib=512),
     notes=[
         'Identical normal-form fixture functions and canonical input values; fresh application graphs each iteration.',
         'Primary metric includes WHNF reduction, complete output decoding/checking and automatic GC.',
         'Input construction is separate; Haskell forces input normal forms and uses opaque suspension boxes to prepare unevaluated applications.',
         'Native allocations, FFI, codec implementations and automatic GC differ. All automatic GC remains charged to its triggering phase.',
         'Explicit GC follows identical round cadence; total sums build, reduction, observation and explicit GC phases.',
         'Memory is complete-process VmHWM, including runtime initialization.',
         'Five fresh-process samples per case, sequential execution, alternating host order, single CPU affinity.'
     ], cases=[])
 def save():
     Path(output).write_text(json.dumps(report, indent=2)+'\n')
 save()
 for kind,n,rounds in cases:
     samples = {host: [] for host in ('haskell','zig')}
     fixture = fixtures / ('append.arboricx' if kind == 'append' else 'id.arboricx')
     for repeat in range(5):
         for host in (('haskell','zig') if repeat % 2 == 0 else ('zig','haskell')):
             command = [haskell if host == 'haskell' else zig, kind, str(n), str(rounds), str(fixture)]
             if host == 'haskell': command += ['+RTS','-N1','-M512m','-K8m','-RTS']
             start = time.monotonic()
             text, sampled_peak = run_guarded(command, memory_mib=512, seconds=65)
             sample = json.loads(text)
             assert (sample['kind'],sample['n'],sample['rounds']) == (kind,n,rounds)
             assert 0 < sample['peak_rss_kib'] <= 512*1024
             sample['process_wall_s'] = time.monotonic()-start
             sample['sampled_peak_rss_kib'] = sampled_peak
             samples[host].append(sample)
     row = dict(kind=kind,n=n,rounds=rounds,hosts={})
     for host,values in samples.items():
         metrics = {}
         for label,fields in dict(evaluate_observe=['reduce_s','observe_s'],
                                  total=['build_s','reduce_s','observe_s','gc_s'],
                                  build=['build_s'], whnf=['reduce_s'], observe=['observe_s'], gc=['gc_s']).items():
             series = [sum(s[f] for f in fields)*1000/rounds for s in values]
             metrics[label] = dict(median=statistics.median(series),min=min(series),max=max(series))
         row['hosts'][host] = dict(samples=values, ms_per_iteration=metrics,
                                  max_peak_rss_mib=max(s['peak_rss_kib'] for s in values)/1024)
     h,z = (row['hosts'][host]['ms_per_iteration']['evaluate_observe']['median'] for host in ('haskell','zig'))
     row['zig_over_haskell_evaluate_observe'] = z/h
     report['cases'].append(row)
     save()
     print(f'{kind}/{n} x{rounds}: Haskell {h:.4f} ms, Zig {z:.4f} ms; Zig/Haskell {z/h:.2f}x', flush=True)
 report['complete'] = True
 save()