#!/usr/bin/env python3 """The SPEED leg of Von and Laya on the deciders bench (Amendment DV-5 of ../../PREREG-von-laya.md). What this file is, for a reader who opened it cold. Exhibit sixty-six ("Small open deciders, measured") prints, for each small decider it ran, what it takes to run: the median seconds a six-way line, one request at a time, and the memory it held. Von and Laya's accuracy legs (VON-1, LAYA-1) ran on a loaded laptop, so their times were conditions, never results (DV1.10). This runner takes the speed readings on the quiet bench box, benchbox: on its processor (torch fp32, the accuracy legs' runtime) and on its RTX 3090 at 300 W (each vendor's server as shipped). speed_deciders.py --arm speed-von-gpu --card-before-only # the card's reading, before any server speed_deciders.py --arm speed-von-gpu --mode dry --server-pid P --card-before F --stamp S speed_deciders.py --arm speed-von-gpu --mode timed --server-pid P --card-before F --stamp S It runs INSIDE the network-less sandbox (sandbox_speed.sh), beside the model's own server, which serve_speed.sh started from its own CLI on 127.0.0.1. Per arm, in this order (DV-5 states each rule first): 1. the pins: every weight file the server reads, the public items it sends, arm 12's instrument, the package and torch builds, and OpenVINO ABSENT (its import phones home; DV1.7). A mismatch stops. 2. the bodies: the 108 six-way bodies rebuilt with no call, each equal to Kev-9B's (the apples-to-apples stop). 3. the guard's heartbeat (outside the sandbox) must be under 10 s old, or nothing is sent. 4. three discarded warm-up requests (task (c) item 0's body, arm 12's practice), never rows. 5. the timed passes: S0's 108 lines through run_kev.task_kc UNEDITED, one request at a time, in kit order, each row's body hash-checked against its twin (the runner exits on a mismatch). `seconds` is run_kev's own timer: the client's wall time for one HTTP round trip over loopback. Three passes; pass 1 is the headline (the page's form: one pass after three warm-ups). The dry run sends the first 5 lines once. 6. the longest input: one synthetic request (DV-3's filler prose, no kit line, no numerals) that each server cuts to its own window, after the timed passes, so the peak memory includes the longest input it takes. THE PEN. A card is named "EVGA GeForce RTX 3090 XC3 Ultra 24 GB", a processor by its model. No UUID, serial, bus, fingerprint or private address is written: the card's UUID lives in the environment only (DV_CARD), and the client never initialises CUDA (so the card's memory reading is the server's alone). """ from __future__ import annotations import argparse import hashlib import importlib.metadata as md import itertools import json import os import statistics import subprocess import sys import time HERE = os.path.dirname(os.path.abspath(__file__)) # instrument/speed INSTR = os.path.dirname(HERE) # instrument ARMDIR = os.path.dirname(INSTR) # bench/deciders-von-laya-2026-10-01 sys.path.insert(0, INSTR) import run_deciders as D # noqa: E402 -- DV-1 to DV-4's runner, unedited: body builder, roster, helpers R, K, hostos = D.R, D.K, D.hostos CARD_NAME = "EVGA GeForce RTX 3090 XC3 Ultra 24 GB" #: sha256("GPU-")[:12] of exhibit sixty-six's card B, as L-2 and O-2 recorded it. The runner checks the #: visible card against it and writes only the verdict (true or false), never the UUID. CARD_B_FINGERPRINT = "33a0b4acb8e8" CAP_W = "300.00" WARMUPS = 3 REPS = {"timed": 3, "dry": 1} DRY_LINES = 5 FILLER = "The quiet harbour keeps its boats close while the tide comes in slowly." # DV-3's probe, verbatim SPEED_ITEMS = ("jev-2026-09-21/kit/task_c.json", "jev-2026-09-21/kit/manifest.json", "jev-2026-09-21/rows-gaps-card/kev-9b.kc.jsonl") SWITCHES = ("HF_HUB_OFFLINE", "TRANSFORMERS_OFFLINE", "HF_HUB_DISABLE_TELEMETRY", "ORT_DISABLE_TELEMETRY", "VLLM_NO_USAGE_STATS", "GRADIO_ANALYTICS_ENABLED", "DO_NOT_TRACK", "OMP_NUM_THREADS", "MKL_NUM_THREADS", "TOKENIZERS_PARALLELISM", "USE_TF", "PYTHONDONTWRITEBYTECODE", "VON_DEVICE", "LAYA_DEVICE", "LAYA_REVISION", "LAYA_MODELS", "LAYA_PRELOAD", "LAYA_THREADS", "LAYA_AUTO_TASK", "LAYA_CPU_AMP", "LAYA_CUDA_AMP", "TORCH_DISABLE_NATIVE_JIT") VON = {"repo": "wfzyx/von", "dist": "von-sdk", "port": 8031, "probe_words": 12000} # DV-3's probe: 13,013 words LAYA = {"repo": "convaiinnovations/laya", "dist": "laya", "port": 8032, "probe_words": 6000} # 36,071 chars < 50,000 ARMS = { "speed-von-cpu": dict(VON, label="SPEED-VON-CPU", device="cpu", torch="2.14.1+cpu", server="von serve --host 127.0.0.1 --port 8031 --device cpu", precision="fp32 (von-sdk casts nothing; the checkpoint is F32)"), "speed-laya-cpu": dict(LAYA, label="SPEED-LAYA-CPU", device="cpu", torch="2.14.1+cpu", server="laya-serve (LAYA_DEVICE=cpu, LAYA_MODELS=english,multilingual, LAYA_PRELOAD=1)", precision="fp32 (LAYA_CPU_AMP unset: laya's shipped CPU default)"), "speed-von-gpu": dict(VON, label="SPEED-VON-GPU", device="cuda", torch="2.14.1+cu130", server="von serve --host 127.0.0.1 --port 8031 --device cuda", precision="fp32 (von-sdk casts nothing; the checkpoint is F32)"), "speed-laya-gpu": dict(LAYA, label="SPEED-LAYA-GPU", device="cuda", torch="2.14.1+cu130", server="laya-serve (LAYA_DEVICE=cuda, LAYA_MODELS=english,multilingual, LAYA_PRELOAD=1)", precision="bf16 autocast (laya's shipped CUDA default: the checkpoint's amp_dtype; " "LAYA_CUDA_AMP unset; the TileLang fast path off, fast=False as shipped)"), } # ------------------------------------------------------------------ small helpers def say(*a) -> None: print(*a, flush=True) def stop(msg: str) -> None: say("STOP: " + msg) sys.exit(2) def utc() -> str: return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) def is_von(arm: str) -> bool: return ARMS[arm]["repo"] == VON["repo"] def is_gpu(arm: str) -> bool: return ARMS[arm]["device"] == "cuda" def nearest_rank(secs: list[float], q: float): """R.summarise's p95 form, for any q: the sorted value at index round(q * (n - 1)).""" s = sorted(secs) return s[min(len(s) - 1, int(round(q * (len(s) - 1))))] if s else None def stats(secs: list[float]) -> dict: return {"n": len(secs), "median_s": statistics.median(secs) if secs else None, "p90_s": nearest_rank(secs, 0.90), "p95_s": nearest_rank(secs, 0.95), "mean_s": statistics.fmean(secs) if secs else None, "min_s": min(secs) if secs else None, "max_s": max(secs) if secs else None, "sum_s": sum(secs), "quantile_rule": "nearest rank: sorted[round(q * (n - 1))], R.summarise's p95 form"} def card_query(fields: str) -> list[str] | None: """One read of the pinned card by its UUID (from the environment; never written).""" uuid = os.environ.get("DV_CARD") or "" if not uuid: return None r = subprocess.run(["nvidia-smi", "--id=" + uuid, "--query-gpu=" + fields, "--format=csv,noheader,nounits"], capture_output=True, text=True, timeout=20) if r.returncode != 0: stop("nvidia-smi could not read the pinned card (rc %d)" % r.returncode) return [x.strip() for x in r.stdout.strip().split(",")] def card_reading() -> dict | None: f = card_query("memory.used,memory.total,power.limit,temperature.gpu,pstate,name,uuid") if f is None: return None fp = hashlib.sha256(f[6].encode()).hexdigest()[:12] return {"utc": utc(), "memory_used_mib": float(f[0]), "memory_total_mib": float(f[1]), "power_limit_w": f[2], "temperature_c": float(f[3]), "pstate": f[4], "chip": f[5], "card": CARD_NAME, "is_card_b": fp == CARD_B_FINGERPRINT} def proc_mb(pid, key): return D.proc_mb(pid, key) def file_sha(path: str) -> str: return D.sha256_file(path) # ------------------------------------------------------------------ 1. the pins def check_pins(arm: str) -> dict: pins = json.load(open(os.path.join(INSTR, "pins.json"), encoding="utf-8")) hf_home = os.environ.get("HF_HOME") or stop("HF_HOME is not set") repo = ARMS[arm]["repo"] a = pins["models"][repo] base = os.path.join(hf_home, "hub", "models--" + repo.replace("/", "--")) if open(os.path.join(base, "refs", "main"), encoding="utf-8").read().strip() != a["revision"]: stop("the cache's refs/main is not the pinned revision") for rel, want in sorted(a["files"].items()): if file_sha(os.path.join(base, "snapshots", a["revision"], rel)) != want: stop("pin mismatch: %s@%s/%s" % (repo, a["revision"][:8], rel)) for rel in SPEED_ITEMS: if file_sha(os.path.join(D.BENCH, rel)) != pins["items"][rel]: stop("item pin mismatch: %s" % rel) for rel, want in sorted(pins["instrument"].items()): if file_sha(os.path.join(D.BENCH, rel)) != want: stop("instrument pin mismatch: %s" % rel) dist = ARMS[arm]["dist"] got = {} for name in (dist, "torch", "openvino", "openvino-telemetry", "onnxruntime"): try: got[name] = md.version(name) except md.PackageNotFoundError: got[name] = None if got[dist] != pins["packages"][dist]: stop("%s is %s, the pin is %s" % (dist, got[dist], pins["packages"][dist])) if got["torch"] != ARMS[arm]["torch"]: stop("torch is %s, this arm's lock says %s" % (got["torch"], ARMS[arm]["torch"])) if got["openvino"] or got["openvino-telemetry"] or got["onnxruntime"]: stop("openvino, openvino-telemetry or onnxruntime is installed; DV-5 times torch and never imports them") files = {rel: file_sha(os.path.join(D.BENCH, rel)) for rel in ( "deciders-von-laya-2026-10-01/instrument/run_deciders.py", "deciders-von-laya-2026-10-01/instrument/fence_probe.py", "deciders-von-laya-2026-10-01/instrument/pins.json", "deciders-von-laya-2026-10-01/instrument/speed/speed_deciders.py", "deciders-von-laya-2026-10-01/instrument/speed/serve_speed.sh", "deciders-von-laya-2026-10-01/instrument/speed/sandbox_speed.sh")} say("PINS %s: %d weight files at %s, %d item files, %d instrument files, %s==%s, torch %s, openvino absent" % (arm, len(a["files"]), a["revision"][:8], len(SPEED_ITEMS), len(pins["instrument"]), dist, got[dist], got["torch"])) return {"revision": a["revision"], "weight_files": len(a["files"]), "instrument_sha256": files, "absent": ["openvino", "openvino-telemetry", "onnxruntime"]} # ------------------------------------------------------------------ 2. the bodies def expected_kc() -> list[tuple]: ros = D.roster() twins = D.jsonl(os.path.join(D.JEV, "rows-gaps-card", "kev-9b.kc.jsonl")) out = [] for i, it in enumerate(R.load("task_c")): want = D.body_sha(*D.six_way_args(it, ros)) if want != twins[i]["prompt_sha256"]: stop("preflight kc c%03d: the rebuilt body differs from Kev-9B's" % i) out.append(("c%03d" % i, it["id"], want)) say("PREFLIGHT kc: %d of %d bodies equal Kev-9B's (no call)" % (len(out), len(twins))) return out # ------------------------------------------------------------------ 3. the guard def guard_fresh() -> dict: hb = os.path.join(os.environ.get("DV_DIR", ""), "guard", "guard.heartbeat") try: age = time.time() - os.path.getmtime(hb) line = open(hb, encoding="utf-8").read().strip() except OSError: stop("no guard heartbeat at %s: the stop guard is not running" % hb) if age > 10: stop("the guard's heartbeat is %.0f s old (the rule: under 10 s)" % age) return {"heartbeat_age_s": round(age, 1), "heartbeat": line} class Arm: # run_kev reads only .host host = None def server_extras(out: dict | None, arm: str) -> dict: out = out or {} usage = out.get("usage") or {} if is_von(arm): trunc = out.get("truncation") return {"state_cut": bool(trunc), "input_tokens_server": usage.get("input_tokens"), "routed_to": None} routing = out.get("routing") or {} cut = usage.get("truncated") return {"state_cut": (bool(cut) if cut is not None else None), "input_tokens_server": usage.get("input_tokens"), "routed_to": routing.get("model")} def von_banner(log_path: str) -> str | None: """The device von-sdk's CLI names in its first line ("[von-1.3 on CPU]"), when the log holds it yet. The banner goes to a redirected stdout, which Python buffers, so it can still be unwritten after the warm-ups; then it is read again at the end of the arm. Its absence never stops a run: the card's growth does (below).""" try: with open(log_path, encoding="utf-8", errors="replace") as fh: for line in fh: if line.startswith("Starting Von Decision Server") and "[" in line: return line.split("[", 1)[1].rsplit("]", 1)[0] except OSError: pass return None def device_seen(arm: str, health: dict, log_path: str, grew_mib: float | None) -> dict: """Where the server computes. A GPU arm whose server did not grow the card by 1,000 MiB, or that names another device, stops; so does a CPU arm whose server names a card (it has no card node and CPU-only torch).""" if is_von(arm): seen = von_banner(log_path) if is_gpu(arm): ok = grew_mib is not None and grew_mib >= 1000 and (seen is None or "CUDA:" in seen) else: ok = seen is None or seen.endswith("on CPU") rec = {"server_says": seen, "grew_at_load_mib": grew_mib} else: devs = health.get("checkpoint_devices") or {} falls = {k: (v or {}).get("count") for k, v in (health.get("cpu_fallbacks") or {}).items()} want = "cuda" if is_gpu(arm) else "cpu" ok = (health.get("device") == want and bool(devs) and all(str(v).startswith(want) for v in devs.values()) and not any(falls.values())) if is_gpu(arm): ok = ok and grew_mib is not None and grew_mib >= 1000 rec = {"server_says": {"device": health.get("device"), "checkpoint_devices": devs, "cpu_fallbacks": falls}, "grew_at_load_mib": grew_mib} if not ok: stop("%s: the server is not computing where this arm says (%s)" % (arm, json.dumps(rec)[:300])) return rec # ------------------------------------------------------------------ 6. the longest input def probe(arm: str, pid: int | None) -> dict: words = ARMS[arm]["probe_words"] filler = " ".join([FILLER] * (words // 12 + 1)) body = {"state": filler, "model": "probe", "questions": {"q": {"type": "noul", "instructions": "Does the state mention a lighthouse?", "criteria": {"true": "It mentions a lighthouse.", "false": "It does not mention a lighthouse."}}}} before = {"rss_mb": proc_mb(pid, "VmRSS"), "hwm_mb": proc_mb(pid, "VmHWM")} t0 = time.monotonic() try: out, err = K.kev_post(Arm.host + "/v1/systemone", body), None except R.SeatError as exc: out, err = None, str(exc)[:300] secs = time.monotonic() - t0 after = {"rss_mb": proc_mb(pid, "VmRSS"), "hwm_mb": proc_mb(pid, "VmHWM")} rec = {"utc": utc(), "filler_words": len(filler.split()), "filler_chars": len(filler), "kit_line_used": False, "seconds": round(secs, 4), "server_before": before, "server_after": after, "error": err, "truncation": (out or {}).get("truncation"), "usage": (out or {}).get("usage"), "answers": (out or {}).get("answers"), "card_after": card_reading()} say("PROBE %s %s" % (arm, json.dumps({k: rec[k] for k in ("filler_words", "seconds", "error", "usage", "truncation")}))) if err: stop("%s: the longest-input probe was refused: %s" % (arm, err)) return rec # ------------------------------------------------------------------ the run def main() -> None: ap = argparse.ArgumentParser() ap.add_argument("--arm", required=True, choices=sorted(ARMS)) ap.add_argument("--mode", choices=("dry", "timed")) ap.add_argument("--card-before-only", action="store_true", help="print the card's reading before any server starts (GPU arms), then exit") ap.add_argument("--preflight", action="store_true", help="the pins and the 108 bodies only: no server, no call, no card read") ap.add_argument("--server-pid", type=int, default=None) ap.add_argument("--card-before", default=None) ap.add_argument("--stamp", default=None) ap.add_argument("--server-log", default=None) a = ap.parse_args() arm = a.arm if a.card_before_only: print(json.dumps({"arm": arm, "device": ARMS[arm]["device"], "card_before_server": card_reading() if is_gpu(arm) else None}, sort_keys=True)) return if a.preflight: check_pins(arm) expected_kc() say("PREFLIGHT ok %s %s (no server, no call, no card read)" % (arm, utc())) return if not a.mode: stop("--mode dry|timed is required") if is_gpu(arm) and not os.environ.get("DV_CARD"): stop("a GPU arm needs the pinned card in DV_CARD") if not is_gpu(arm) and (os.environ.get("CUDA_VISIBLE_DEVICES") or "") != "": stop("a CPU arm runs with CUDA_VISIBLE_DEVICES empty") if os.environ.get("DO_NOT_TRACK") is not None: stop("DO_NOT_TRACK is set; the house list never sets it") t0 = time.monotonic() pin = check_pins(arm) exp = expected_kc() guard0 = guard_fresh() card_before = json.load(open(a.card_before, encoding="utf-8")) if a.card_before else {} cb = card_before.get("card_before_server") if is_gpu(arm): if not cb or not cb["is_card_b"] or cb["power_limit_w"] != CAP_W or cb["memory_used_mib"] > 50: stop("the card before the server is not card B, alone, at %s W: %s" % (CAP_W, json.dumps({k: (cb or {}).get(k) for k in ("is_card_b", "power_limit_w", "memory_used_mib")}))) say("PREFLIGHT ok %s in %.1f s (no model call); guard %s" % (utc(), time.monotonic() - t0, json.dumps(guard0))) Arm.host = "http://127.0.0.1:%d" % ARMS[arm]["port"] t1, health = time.monotonic(), None while time.monotonic() - t1 < 900: try: health = D.get(Arm.host, "/health") break except Exception: # noqa: BLE001 -- not up yet time.sleep(0.5) if health is None: stop("%s did not answer /health in 900 s" % ARMS[arm]["server"]) ready_s = time.monotonic() - t1 # 4. three discarded warm-ups: c000's body, arm 12's practice. Never rows. ros = D.roster() item0 = R.load("task_c")[0] warm = [] for i in range(WARMUPS): w = K.kev_decide(Arm, *D.six_way_args(item0, ros)) if w.get("refused") or w.get("prompt_sha256") != exp[0][2]: stop("warm-up %d: refused, or its body differs from c000's" % (i + 1)) warm.append(round(w["seconds"], 4)) card_after_warm = card_reading() if is_gpu(arm) else None grew = card_after_warm["memory_used_mib"] - cb["memory_used_mib"] if is_gpu(arm) else None health_after = D.get(Arm.host, "/health") # after the warm-ups (laya names its devices) seen = device_seen(arm, health_after, a.server_log or "", grew) load = {"server_ready_s": round(ready_s, 2), "warmup_seconds": warm, "server_rss_mb_after_warmups": proc_mb(a.server_pid, "VmRSS"), "server_hwm_mb_after_warmups": proc_mb(a.server_pid, "VmHWM"), "card_before_server": cb, "card_after_warmups": card_after_warm, "grew_at_load_mib": grew} say("LOADED %s ready %.1f s; warm-ups %s; device %s; grew %s MiB" % ( arm, ready_s, warm, json.dumps(seen["server_says"])[:160], load["grew_at_load_mib"])) ver = D.versions(ARMS[arm]["dist"]) os_rec = hostos.read_os() switches = {k: os.environ.get(k) for k in SWITCHES} switches["CUDA_VISIBLE_DEVICES"] = ("" if is_gpu(arm) else os.environ.get("CUDA_VISIBLE_DEVICES")) switches["HF_HOME"] = "/hf" meta = {"arm": arm, "label": ARMS[arm]["label"], "mode": a.mode, "model": "%s@%s" % (ARMS[arm]["repo"], pin["revision"]), "server": ARMS[arm]["server"], "device": ARMS[arm]["device"], "card": CARD_NAME if is_gpu(arm) else None, "power_limit_w": (cb or {}).get("power_limit_w") if is_gpu(arm) else None, "precision": ARMS[arm]["precision"], "box": "benchbox", "processor": D.processor_model(), "cpu_affinity": sorted(os.sched_getaffinity(0)), "threads": os.environ.get("OMP_NUM_THREADS"), "os": os_rec, "versions": ver, "switches": switches, "health": health_after, "device_seen": seen, "pins": pin, "seed": K.SEED, "warmups": WARMUPS, "protocol": "one request at a time, in kit order, through run_kev.task_kc unedited; seconds = the " "client's wall time for one HTTP round trip over loopback (run_kev.kev_decide's timer)"} out_dir = os.path.join(os.environ["DV_DIR"], "rows-speed" if a.mode == "timed" else "rows-speed-dry") os.makedirs(out_dir, exist_ok=True) reps = [] for rep in range(1, REPS[a.mode] + 1): tag = "rep%d" % rep if a.mode == "timed" else "dry" path = os.path.join(out_dir, "%s.kc.%s.jsonl" % (arm, tag)) if os.path.exists(path): stop("%s exists: a speed file is never overwritten (a re-run is a numbered amendment)" % path) started, tw0 = utc(), time.monotonic() gen = K.task_kc(Arm, None, None) rows = [] with open(path, "w", encoding="utf-8") as fh: for i, row in enumerate(gen if a.mode == "timed" else itertools.islice(gen, DRY_LINES)): uid, iid, want = exp[i] if row["id"] != iid or row.get("uid") != uid: stop("kc row %d: id/uid %s/%s, the kit says %s/%s" % (i, row["id"], row.get("uid"), iid, uid)) if row.get("refused") or row.get("prompt_sha256") != want: stop("kc %s: refused, or the body sent differs from Kev-9B's" % uid) row.update(server_extras(row.get("kev_response"), arm)) row.update(arm=arm, label_arm=ARMS[arm]["label"], model=meta["model"], server=meta["server"], box="benchbox", processor=meta["processor"], device=meta["device"], card=meta["card"], power_limit_w=meta["power_limit_w"], precision=meta["precision"], os=os_rec, python=ver["python"], torch=ver.get("torch"), transformers=ver.get("transformers"), tokenizers=ver.get("tokenizers"), package=ver.get(ARMS[arm]["dist"]), cpu_affinity=meta["cpu_affinity"], threads=meta["threads"], rep=tag, server_rss_mb=proc_mb(a.server_pid, "VmRSS"), seed=K.SEED, stamp=utc(), speed_leg=True, dry=a.mode == "dry", accuracy_counted=False, latency_published=a.mode == "timed", prompt_sha256_matches_twin=True) fh.write(json.dumps(row, ensure_ascii=False) + "\n") fh.flush() rows.append(row) say("ROW %s %s %s %s %.4fs" % (arm, tag, uid, "RIGHT" if row.get("choice") == row.get("label") else "wrong", row["seconds"])) wall = time.monotonic() - tw0 secs = [r["seconds"] for r in rows] rs = {"rep": tag, "file": os.path.basename(path), "started": started, "ended": utc(), "wall_seconds": round(wall, 3), "stats": stats(secs), "summarise": R.summarise(rows), "server_hwm_mb_at_end": proc_mb(a.server_pid, "VmHWM"), "card_at_end": card_reading() if is_gpu(arm) else None} reps.append(rs) say("PASS %s %s %s" % (arm, tag, json.dumps({k: rs["stats"][k] for k in ("n", "median_s", "p90_s", "p95_s")}))) pr = probe(arm, a.server_pid) summary = {"arm": arm, "mode": a.mode, "stamp": a.stamp, "ended": utc(), "meta": meta, "load": load, "passes": reps, "headline_pass": reps[0]["rep"], "probe": pr, "server_hwm_mb_final": proc_mb(a.server_pid, "VmHWM"), "von_banner_at_end": von_banner(a.server_log or "") if is_von(arm) else None, "guard_at_start": guard0, "latency_published": a.mode == "timed"} with open(os.path.join(out_dir, "%s.%s.speed.json" % (arm, a.mode)), "w", encoding="utf-8") as fh: json.dump(summary, fh, indent=1, ensure_ascii=False, sort_keys=True) fh.write("\n") say("DONE %s %s %s" % (arm, a.mode, utc())) if __name__ == "__main__": main()