#!/usr/bin/env python3 """Compare V5, V7 and V8 admission with every final checkpoint included. Linux/POSIX regular-file prototype measurements only. No native NTFS result, physical NAND measurement, simulated force delay, or device fault qualification. """ from __future__ import annotations import argparse import hashlib import importlib.util import json from pathlib import Path import platform import random import statistics import sys import tempfile import time sys.dont_write_bytecode = True HERE = Path(__file__).resolve().parent ROOT = HERE.parent def load(name, path): spec = importlib.util.spec_from_file_location(name, path) module = importlib.util.module_from_spec(spec) sys.modules[name] = module spec.loader.exec_module(module) return module def sha(path): return hashlib.sha256(path.read_bytes()).hexdigest() def percentile(values, q): values = sorted(values) point = (len(values) - 1) * q lower = int(point) upper = min(lower + 1, len(values) - 1) return values[lower] + (values[upper] - values[lower]) * (point - lower) def value(label, index): return hashlib.shake_256(f'{label}/{index}'.encode()).digest(128) def workload(namespace, operations, kind): if kind == 'bulk_append': # A separate atomic workload: one durable transaction contains 128 new # keys. Transaction throughput and logical-key throughput differ. return [({f'/append/{i:04d}/{j:04d}': value('append', i * 128 + j) for j in range(128)}, f'append-{i:06d}') for i in range(64)] names = [f'/file/{i:06d}' for i in range(namespace)] candidates = [p for p in names if hashlib.sha256(p.encode()).hexdigest().startswith('0')] if kind == 'hot_prefix' else names if not candidates: raise ValueError('namespace has no hot-prefix keys') rng = random.Random(601131) return [({rng.choice(candidates): value(kind, i)}, f'{kind}-{i:06d}') for i in range(operations)] def allocation(path): stat = path.stat() return {'apparent_bytes': stat.st_size, 'filesystem_allocated_bytes': getattr(stat, 'st_blocks', 0) * 512} def run_trial(module, backend, namespace, requests, pool_blocks, kind, trial): initial = {f'/file/{i:06d}': value('initial', i) for i in range(namespace)} expected = dict(initial) epochs = {} with tempfile.TemporaryDirectory(prefix='nyarion-admission-benchmark-') as tmp: image = Path(tmp) / 'volume.img' store = module.PageStore.create(image, initial_files=initial, pool_blocks=pool_blocks) before_allocation = allocation(image) store.reset_stats() latency = [] started = time.perf_counter_ns() for changes, token in requests: begin = time.perf_counter_ns() epoch = store.transact(changes, token) latency.append((time.perf_counter_ns() - begin) / 1e6) epochs[token] = epoch transaction_end = time.perf_counter_ns() store.checkpoint() finished = time.perf_counter_ns() stats = dict(store.stats) if backend == 'v8': assert stats.get('full_graph_scans') == 0, 'timed V8 workload must not scan the full graph' elapsed = (finished - started) / 1e9 for changes, _ in requests: expected.update(changes) assert store.files() == sorted(expected) for key, data in expected.items(): assert store.get(key) == data for token, epoch in epochs.items(): assert store.query(token)['epoch'] == epoch assert store.epoch == len(requests) after_allocation = allocation(image) store.close() with module.PageStore(image, writable=False) as reopened: assert reopened.epoch == len(requests) assert reopened.files() == sorted(expected) for key, data in expected.items(): assert reopened.get(key) == data for token, epoch in epochs.items(): assert reopened.query(token)['epoch'] == epoch request_digest = hashlib.sha256(json.dumps( [[[key, hashlib.sha256(data).hexdigest()] for key, data in sorted(changes.items())] + [token] for changes, token in requests], separators=(',', ':')).encode()).hexdigest() logical_updates = sum(len(changes) for changes, _ in requests) return {'backend': backend, 'namespace_files': namespace, 'workload': kind, 'workload_sha256': request_digest, 'trial': trial, 'transactions': len(requests), 'value_bytes': 128, 'logical_key_updates': logical_updates, 'keys_per_transaction': len(requests[0][0]), 'elapsed_with_final_checkpoint_seconds': elapsed, 'drained_transactions_per_second': len(requests) / elapsed, 'drained_logical_key_updates_per_second': logical_updates / elapsed, 'transaction_calls_seconds': (transaction_end - started) / 1e9, 'final_checkpoint_ms': (finished - transaction_end) / 1e6, 'latencies_ms': latency, 'latency_ms_p50': percentile(latency, .5), 'latency_ms_p95': percentile(latency, .95), 'latency_ms_p99': percentile(latency, .99), 'latency_ms_max': max(latency), 'engine_stats': stats, 'allocation_before': before_allocation, 'allocation_after': after_allocation, 'configured_arena_blocks': pool_blocks, 'configured_arena_bytes': pool_blocks * 4096, 'all_values_and_exact_token_epochs_verified_before_and_after_reopen': True} def filesystem_type(path): try: path = str(Path(path).resolve()) matches = [] for line in Path('/proc/mounts').read_text().splitlines(): fields = line.split() mount = fields[1].replace('\\040', ' ') if path == mount or path.startswith(mount.rstrip('/') + '/'): matches.append((len(mount), fields[2])) return max(matches)[1] if matches else 'unknown' except (OSError, IndexError): return 'unknown' def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--namespaces', nargs='+', type=int, default=[4096, 16384, 65536]) parser.add_argument('--operations', type=int, default=128) parser.add_argument('--trials', type=int, default=3) parser.add_argument('--pool-blocks', type=int, default=32768) parser.add_argument('--output', type=Path, default=HERE / 'benchmark_final_results.json') args = parser.parse_args() if min(*args.namespaces, args.operations, args.trials, args.pool_blocks) < 1: parser.error('positive sizes required') paths = {'v5': HERE / 'baselines/v5.py', 'v7': HERE / 'baselines/v7.py', 'v8': ROOT / 'pagefs.py', 'benchmark': Path(__file__).resolve()} hashes = {name: sha(path) for name, path in paths.items()} modules = {name: load('v8_benchmark_' + name, paths[name]) for name in ('v5', 'v7', 'v8')} rows = [] configurations = [(n, kind) for n in args.namespaces for kind in ('hot_prefix', 'uniform')] configurations.append((0, 'bulk_append')) for n, kind in configurations: requests = workload(n, args.operations, kind) for trial in range(args.trials): backends = ('v5', 'v7', 'v8') shift = trial % len(backends) order = backends[shift:] + backends[:shift] for backend in order: print(f'{backend}: N={n}, {kind}, trial {trial + 1}', flush=True) rows.append(run_trial(modules[backend], backend, n, requests, args.pool_blocks, kind, trial)) assert hashes == {name: sha(path) for name, path in paths.items()}, 'source changed during measurement' summaries = [] comparisons = [] for n, kind in configurations: grouped = {} for backend in ('v5', 'v7', 'v8'): group = [row for row in rows if row['backend'] == backend and row['namespace_files'] == n and row['workload'] == kind] summary = {'backend': backend, 'namespace_files': n, 'workload': kind, 'trials': len(group), 'transactions': group[0]['transactions'], 'logical_key_updates': group[0]['logical_key_updates'], 'keys_per_transaction': group[0]['keys_per_transaction']} for field in ('drained_transactions_per_second', 'drained_logical_key_updates_per_second', 'elapsed_with_final_checkpoint_seconds', 'final_checkpoint_ms', 'latency_ms_p50', 'latency_ms_p95', 'latency_ms_p99', 'latency_ms_max'): summary['median_' + field] = statistics.median(row[field] for row in group) for field in sorted(set().union(*(row['engine_stats'] for row in group))): values = [row['engine_stats'].get(field, 0) for row in group] if all(type(v) in (int, float) for v in values): summary['median_' + field] = statistics.median(values) grouped[backend] = summary summaries.append(summary) a, b, c = grouped['v5'], grouped['v7'], grouped['v8'] comparisons.append({'namespace_files': n, 'workload': kind, 'transactions': c['transactions'], 'keys_per_transaction': c['keys_per_transaction'], 'logical_key_updates': c['logical_key_updates'], 'v7_over_v5_drained_throughput': b['median_drained_transactions_per_second'] / a['median_drained_transactions_per_second'], 'v8_over_v7_drained_throughput': c['median_drained_transactions_per_second'] / b['median_drained_transactions_per_second'], 'v8_over_v5_drained_throughput': c['median_drained_transactions_per_second'] / a['median_drained_transactions_per_second'], 'v5_over_v8_host_write_bytes': a['median_bytes_written'] / c['median_bytes_written'], 'v5_over_v7_host_write_bytes': a['median_bytes_written'] / b['median_bytes_written'], 'v5_final_checkpoint_ms': a['median_final_checkpoint_ms'], 'v7_final_checkpoint_ms': b['median_final_checkpoint_ms'], 'v8_final_checkpoint_ms': c['median_final_checkpoint_ms']}) result = {'benchmark': 'V5/V7/V8 end-to-end admission comparison including final window drain', 'date': '2026-11-01', 'engine_source_sha256': hashes, 'sources_unchanged_during_measurement': True, 'environment': {'os': platform.system(), 'python': platform.python_version(), 'temporary_filesystem': filesystem_type(tempfile.gettempdir())}, 'method': {'trials': args.trials, 'order': 'three-way rotating backend order; each engine starts one trial per workload', 'timing': 'all transaction admission/planning, automatic maintenance, and one explicit final checkpoint; setup/open and validation excluded', 'logical_workload': 'single-key: identical seeded key sequence and 128-byte values, hot means SHA-256 first nibble 0; separate bulk-append: empty genesis, 64 atomic transactions with 128 new 128-byte keys each (8192 logical key updates)', 'verification': 'every file name/value and exact transaction receipt epoch before and after read-only reopen', 'host_writes': 'engine requested bytes, not NAND traffic', 'capacity': 'all three use the same configured fixed arena'}, 'limits': ['Different admission guarantees: V5 can acknowledge an arena-undrainable tail; V7 and V8 precheck logical checkpoint capacity.', 'POSIX regular-file prototype comparison, not native NTFS.', 'All live logical data remain in RAM; no physical power-cut or device qualification.', 'No simulated flush latency, cache dropping, or direct I/O.'], 'trials': rows, 'summaries': summaries, 'comparisons': comparisons} args.output.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') print(json.dumps(comparisons, indent=2), flush=True) if __name__ == '__main__': main()