| |
| """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': |
| |
| |
| 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() |
|
|
