118 lines
3.5 KiB
Python
118 lines
3.5 KiB
Python
"""Regenerate the DGR-012 concurrency-sweep evidence artifact.
|
|
|
|
Deterministic, download-free, GPU-free. Run from the repo root with the default
|
|
venv so the worktree ``meshnet_node`` package and the DGR-007 numpy reference
|
|
(``tests/test_hot_kv_state``) are importable:
|
|
|
|
python .scratch/distributed-gguf-runtime/evidence/DGR-012/generate_evidence.py
|
|
|
|
Writes ``results.json`` beside this script.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import pathlib
|
|
import sys
|
|
|
|
_ROOT = pathlib.Path(__file__).resolve().parents[4]
|
|
sys.path.insert(0, str(_ROOT / "packages" / "node"))
|
|
sys.path.insert(0, str(_ROOT / "tests"))
|
|
|
|
from test_hot_kv_state import _KvDenseLlama, _KvReferenceShard # noqa: E402
|
|
|
|
from meshnet_node.batch_scheduler import ( # noqa: E402
|
|
ContinuousBatchScheduler,
|
|
GenerationRequest,
|
|
KvBatchEngine,
|
|
NodeBudget,
|
|
run_concurrency_sweep,
|
|
)
|
|
from meshnet_node.hot_kv_state import ( # noqa: E402
|
|
HotKvStateManager,
|
|
KvBoundaryAdapter,
|
|
kv_recipe_for,
|
|
)
|
|
|
|
MODEL = _KvDenseLlama()
|
|
|
|
|
|
def make_engine() -> KvBatchEngine:
|
|
shard = _KvReferenceShard(MODEL, 0, MODEL.n_layers - 1)
|
|
manager = HotKvStateManager(kv_recipe_for(shard))
|
|
return KvBatchEngine(KvBoundaryAdapter(shard, manager))
|
|
|
|
|
|
def main() -> int:
|
|
prompts = {
|
|
"s0": [1, 2, 3, 4], "s1": [5, 6, 7, 8], "s2": [9, 10, 11, 12],
|
|
"s3": [13, 14, 15, 16], "s4": [17, 18, 19, 20], "s5": [21, 22, 23, 24],
|
|
"s6": [25, 26, 27, 28], "s7": [29, 30, 31, 32],
|
|
}
|
|
n_new = 8
|
|
requests = [
|
|
GenerationRequest(sid, 0, tuple(p), n_new) for sid, p in prompts.items()
|
|
]
|
|
sweep = run_concurrency_sweep(
|
|
make_engine, requests, concurrency_levels=(1, 2, 4, 8)
|
|
)
|
|
|
|
# A representative telemetry snapshot mid-run at concurrency 4 (shows the live
|
|
# capability signals a node advertises upward).
|
|
engine = make_engine()
|
|
scheduler = ContinuousBatchScheduler(
|
|
engine,
|
|
NodeBudget(
|
|
max_active_sessions=4, max_batch_size=4, max_queue_depth=8,
|
|
scratch_bytes_per_session=1, scratch_budget_bytes=4,
|
|
),
|
|
)
|
|
for request in requests:
|
|
scheduler.submit(request)
|
|
for _ in range(6):
|
|
scheduler.run_tick()
|
|
mid_run_telemetry = scheduler.telemetry().to_dict()
|
|
|
|
artifact = {
|
|
"schema_version": 1,
|
|
"evidence_kind": "synthetic-unit",
|
|
"model": {
|
|
"reference": "pure-numpy KV-cached dense-Llama (tests/test_hot_kv_state)",
|
|
"n_layers": MODEL.n_layers,
|
|
"hidden": MODEL.hidden,
|
|
"n_heads": MODEL.n_heads,
|
|
"vocab": MODEL.vocab,
|
|
},
|
|
"workload": {
|
|
"sessions": len(prompts),
|
|
"prompt_len": 4,
|
|
"max_new_tokens": n_new,
|
|
},
|
|
"concurrency_sweep": sweep.to_dict(),
|
|
"mid_run_telemetry_concurrency_4": mid_run_telemetry,
|
|
}
|
|
|
|
out = pathlib.Path(__file__).with_name("results.json")
|
|
out.write_text(json.dumps(artifact, indent=2, sort_keys=True) + "\n", encoding="utf-8")
|
|
print(f"wrote {out}")
|
|
print(
|
|
"saturation_concurrency=%d corruption_free=%s"
|
|
% (sweep.saturation_concurrency, sweep.corruption_free)
|
|
)
|
|
for result in sweep.results:
|
|
print(
|
|
" c=%d ticks=%d avg_occ=%.3f tokens/tick=%.3f peak_kv=%dB"
|
|
% (
|
|
result.concurrency,
|
|
result.ticks,
|
|
result.avg_batch_occupancy,
|
|
result.tokens_per_tick,
|
|
result.peak_kv_bytes,
|
|
)
|
|
)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|