qcoder 0.1.0a0__py3-none-any.whl

qcoder/tools/runners/quantum_rings/v12/runner.py

@@ -0,0 +1,549 @@
+#!/usr/bin/env python3
+"""
+qr12_runner.py
+
+QR12 single-purpose runner -> one JSON per run (top-K only) plus SDK-native metrics (best-effort).
+
+Why this exists:
+- In QR11 we assumed result.get_fidelity / result.get_peakmemorysize_0 were missing or unreliable.
+- In QR12, they appear to exist, so we:
+  - keep our external timing + peak RSS sampler
+  - ALSO record built-in SDK metrics if callable
+
+Outputs:
+- JSON per run with:
+  - timing_s.run_wall_s
+  - memory.peak_rss_bytes / peak_rss_mb  (external sampler)
+  - sdk_metrics.get_fidelity / get_peakmemorysize_0 / get_memory (best-effort)
+  - hist.top (top-K counts), tail_mass, unique_outcomes
+
+NOTE:
+- We keep your CUDA DLL search-path bootstrap (critical for your unusual CUDA DLL folder layout).
+"""
+
+from qcoder.tools import qr_dll_bootstrap
+
+qr_dll_bootstrap.bootstrap()
+
+import argparse
+import datetime as _dt
+import hashlib
+import importlib.metadata as _imd
+import json
+import os
+import platform
+import re
+import subprocess
+import sys
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+import psutil
+
+from QuantumRingsLib import QuantumRingsProvider, QuantumCircuit as QR_Circuit, job_monitor
+
+
+# -----------------------------
+# Helpers
+# -----------------------------
+
+def die(msg: str, code: int = 1) -> None:
+    print(f"[fatal] {msg}", file=sys.stderr, flush=True)
+    sys.exit(code)
+
+def read_file(path: str) -> str:
+    if not path:
+        die("No QASM path provided.")
+    if not os.path.exists(path):
+        die(f"File not found: {path}")
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        return f.read()
+
+def sha256_file(path: str, chunk_size: int = 1 << 20) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(chunk_size)
+            if not b:
+                break
+            h.update(b)
+    return h.hexdigest()
+
+def first_noncomment_nonblank_line(text: str) -> Optional[str]:
+    for line in text.splitlines():
+        s = line.strip()
+        if not s:
+            continue
+        if s.startswith("//"):
+            continue
+        return s
+    return None
+
+def sanitize_qasm2_identifiers(text: str) -> Tuple[str, Dict[str, str]]:
+    """
+    Rename qreg/creg identifiers that can conflict with gate names in some parsers.
+    Preserve your existing behavior.
+    """
+    target = {"x": "xr", "y": "yr", "t": "anc"}
+    decls = re.findall(r'^\s*(qreg|creg)\s+([A-Za-z_]\w*)\s*\[\d+\]\s*;', text, flags=re.M)
+    need = {name for _, name in decls if name in target}
+    if not need:
+        return text, {}
+    renames = {old: target[old] for old in need}
+
+    for old, new in renames.items():
+        text = re.sub(rf'(^\s*qreg\s+){old}(\s*\[\d+\]\s*;)', rf'\1{new}\2', text, flags=re.M)
+        text = re.sub(rf'(^\s*creg\s+){old}(\s*\[\d+\]\s*;)', rf'\1{new}\2', text, flags=re.M)
+
+    for old, new in renames.items():
+        text = re.sub(rf'(?<![A-Za-z0-9_]){old}\[', f'{new}[', text)
+
+    return text, renames
+
+def has_measures(qc: QR_Circuit) -> bool:
+    try:
+        if getattr(qc, "num_clbits", 0) > 0:
+            return True
+    except Exception:
+        pass
+    try:
+        ops = qc.count_ops()
+        return bool(ops.get("measure", 0))
+    except Exception:
+        return False
+
+def try_nvidia_smi() -> Optional[Dict[str, Any]]:
+    """
+    Best-effort GPU info. If nvidia-smi isn't available, return None.
+    """
+    try:
+        cmd = [
+            "nvidia-smi",
+            "--query-gpu=name,driver_version,memory.total",
+            "--format=csv,noheader,nounits",
+        ]
+        p = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        if p.returncode != 0:
+            return None
+        line = (p.stdout.strip().splitlines() or [""])[0].strip()
+        if not line:
+            return None
+        parts = [x.strip() for x in line.split(",")]
+        if len(parts) >= 3:
+            return {
+                "gpu_name": parts[0],
+                "driver_version": parts[1],
+                "gpu_memory_total_mb": float(parts[2]) if parts[2].replace(".", "", 1).isdigit() else parts[2],
+            }
+        return {"raw": line}
+    except Exception:
+        return None
+
+def resolve_backend_id(provider: QuantumRingsProvider, backend_arg: str, precision: str) -> str:
+    """
+    Accept friendly names (Scarlet/Amber/Serin or CPU/GPU/Both) OR raw backend ids.
+    """
+    if not backend_arg:
+        return "scarlet_quantum_rings"
+
+    b = backend_arg.strip()
+    if "_" in b or b.endswith("_quantum_rings"):
+        return b
+
+    key = b.lower()
+    if key in ("scarlet", "cpu"):
+        candidates = ["scarlet_quantum_rings", "scarlet"]
+    elif key in ("amber", "gpu"):
+        candidates = ["amber_quantum_rings", "amber"]
+    elif key in ("serin", "both", "hybrid"):
+        candidates = ["serin_quantum_rings", "serin"]
+    else:
+        candidates = [b]
+
+    last_err = None
+    for cid in candidates:
+        try:
+            _ = provider.get_backend(cid, precision=precision)
+            return cid
+        except Exception as e:
+            last_err = e
+    die(f"Could not resolve backend '{backend_arg}'. Tried: {candidates}. Last error: {last_err}")
+    return b  # unreachable
+
+def default_json_out(qasm_path: str, backend_id: str, precision: str, threshold: int, shots: int, out_dir: str) -> str:
+    base = os.path.splitext(os.path.basename(qasm_path))[0]
+    fname = f"{base}__{backend_id}__{precision}__thr{threshold}__shots{shots}.json"
+    return os.path.join(out_dir, fname)
+
+def start_peak_rss_sampler(interval_s: float = 0.05):
+    import threading
+    import time as _time
+    import os as _os
+
+    proc = psutil.Process(_os.getpid())
+    peak = {"rss": 0}
+    running = {"on": True}
+
+    def _loop():
+        while running["on"]:
+            try:
+                rss = proc.memory_info().rss
+                if rss > peak["rss"]:
+                    peak["rss"] = rss
+            except Exception:
+                pass
+            _time.sleep(interval_s)
+
+    th = threading.Thread(target=_loop, daemon=True)
+    th.start()
+    return running, th, peak
+
+def stop_peak_rss_sampler(running, th):
+    running["on"] = False
+    th.join(timeout=1.0)
+
+_QREG_DECL_LINE = re.compile(r'^\s*qreg\s+([A-Za-z_]\w*)\s*\[(\d+)\]\s*;\s*$', re.M)
+
+def normalize_terminal_measurements_qasm2(text: str) -> str:
+    """
+    If SDK complains about classical bits vs qubits mismatch, we:
+    - drop existing creg + measure lines
+    - create a new creg meas[total_qubits]
+    - append explicit terminal measurement of every qubit -> meas[i]
+    """
+    regs = [(m.group(1), int(m.group(2))) for m in _QREG_DECL_LINE.finditer(text)]
+    if not regs:
+        return text
+
+    total = sum(n for _, n in regs)
+
+    lines = text.splitlines()
+    kept = []
+    last_qreg_idx = -1
+    for i, line in enumerate(lines):
+        s = line.strip()
+        if s.startswith("qreg "):
+            last_qreg_idx = i
+            kept.append(line)
+            continue
+        if s.startswith("creg "):
+            continue
+        if s.startswith("measure "):
+            continue
+        kept.append(line)
+
+    insert_at = max(0, last_qreg_idx + 1)
+    kept.insert(insert_at, f"creg meas[{total}];")
+
+    out = kept[:]
+    out.append("")
+    k = 0
+    for name, n in regs:
+        for qi in range(n):
+            out.append(f"measure {name}[{qi}] -> meas[{k}];")
+            k += 1
+
+    return "\n".join(out) + "\n"
+
+def get_dist_version(names: List[str]) -> Optional[str]:
+    for n in names:
+        try:
+            return _imd.version(n)
+        except Exception:
+            pass
+    return None
+
+def safe_call_result_getter(result: Any, name: str):
+    """
+    Best-effort: call result.<name>() if it exists and is no-arg.
+    Returns: (value, error_string_or_None)
+    """
+    if not hasattr(result, name):
+        return None, "missing"
+    try:
+        return getattr(result, name)(), None
+    except Exception as e:
+        return None, repr(e)
+
+def jsonable_value(x: Any) -> Any:
+    if x is None:
+        return None
+    if isinstance(x, (str, int, float, bool)):
+        return x
+    # Some SDK objects won't serialize; store repr
+    return repr(x)
+
+
+# -----------------------------
+# Main
+# -----------------------------
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description="QR12 single run: run one QASM once and emit one JSON (top-K only) + SDK native metrics."
+    )
+    ap.add_argument("qasm", help="Path to .qasm (intended QASM2; header comments OK)")
+    ap.add_argument("--backend", default="Scarlet",
+                    help="Backend: Scarlet|Amber|Serin (or CPU/GPU/Both) OR backend id like scarlet_quantum_rings")
+    ap.add_argument("--precision", choices=["single", "double"], default="single",
+                    help="Numeric precision passed to get_backend")
+    ap.add_argument("--threshold", type=int, default=128,
+                    help="Threshold knob (performance='custom')")
+    ap.add_argument("--shots", type=int, default=10000,
+                    help="Number of shots")
+    ap.add_argument("--topk", type=int, default=50,
+                    help="Emit top-K bitstrings only")
+    ap.add_argument("--json-out", default=None,
+                    help="Output JSON path (default: runs/<auto>.json)")
+    ap.add_argument("--out-dir", default="runs",
+                    help="Directory for default JSON output name when --json-out not provided")
+    ap.add_argument("--save-qasm-post", default=None,
+                    help="Optional: save sanitized QASM that is executed")
+    ap.add_argument("--print-ops", action="store_true",
+                    help="Print operation counts before running")
+
+    args = ap.parse_args()
+
+    print("===== QR12 Single-Run Runner =====", flush=True)
+
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    # Identify installed distribution (helps debugging env mismatch)
+    sdk_pkg = "quantumrings-cuda13x"
+    sdk_ver = get_dist_version([sdk_pkg, "quantumrings_cuda13x", "QuantumRingsLib"])
+    print(f"[env] sdk_pkg={sdk_pkg} sdk_version={sdk_ver} python={sys.version.split()[0]}", flush=True)
+
+    # Provider first (SDK may validate entitlements during circuit load)
+    provider = QuantumRingsProvider()
+
+    # Backend resolution + get_backend with precision
+    backend_id = resolve_backend_id(provider, args.backend, args.precision)
+    backend = provider.get_backend(backend_id, precision=args.precision)
+    print(f"[backend] {backend}", flush=True)
+
+    # Read + basic header check (non-fatal unless empty)
+    text = read_file(args.qasm)
+    first_stmt = first_noncomment_nonblank_line(text)
+    if first_stmt is None:
+        die("QASM file is empty.")
+    if first_stmt.upper().startswith("OPENQASM") and not first_stmt.upper().startswith("OPENQASM 2.0"):
+        print(f"[warn] header is not 'OPENQASM 2.0': {first_stmt}", flush=True)
+
+    # Sanitize identifiers
+    text_fixed, renames = sanitize_qasm2_identifiers(text)
+    if renames:
+        print(f"[sanitize] renamed identifiers: {renames}", flush=True)
+
+    # Optionally save post-QASM
+    if args.save_qasm_post:
+        os.makedirs(os.path.dirname(args.save_qasm_post) or ".", exist_ok=True)
+        with open(args.save_qasm_post, "w", encoding="utf-8") as f:
+            f.write(text_fixed)
+        print(f"[ok] wrote post.qasm: {args.save_qasm_post}", flush=True)
+
+    # Load circuit (with normalization fallback)
+    try:
+        qc = QR_Circuit.from_qasm_str(text_fixed)
+        text_executed = text_fixed
+    except Exception as e:
+        msg = str(e).lower()
+        if "classical bits" in msg and "qubits" in msg:
+            print("[warn] QASM load failed due to classical/qubit mismatch; normalizing terminal measurements and retrying.", flush=True)
+            text_norm = normalize_terminal_measurements_qasm2(text_fixed)
+            if args.save_qasm_post:
+                os.makedirs(os.path.dirname(args.save_qasm_post) or ".", exist_ok=True)
+                with open(args.save_qasm_post, "w", encoding="utf-8") as f:
+                    f.write(text_norm)
+                print(f"[ok] wrote normalized post.qasm: {args.save_qasm_post}", flush=True)
+            qc = QR_Circuit.from_qasm_str(text_norm)
+            text_executed = text_norm
+        else:
+            die(f"QASM load failed: {e}")
+
+    # Basic info
+    try:
+        n_qubits = int(qc.num_qubits)
+    except Exception:
+        n_qubits = None
+    print(f"[circuit] qubits={n_qubits if n_qubits is not None else '?'}", flush=True)
+
+    if args.print_ops:
+        try:
+            ops = qc.count_ops()
+            total_ops = sum(int(v) for v in ops.values())
+            print(f"[ops] total={total_ops}", flush=True)
+            for k, v in sorted(ops.items(), key=lambda kv: kv[1], reverse=True):
+                print(f"   {k:12s}: {int(v)}", flush=True)
+        except Exception as e:
+            print(f"[ops] count_ops unavailable: {e}", flush=True)
+
+    if not has_measures(qc):
+        die("Circuit has no measurements / classical bits; cannot produce counts. Fix the QASM or add measurements.")
+
+    # Run settings (consistent with your harness assumptions)
+    run_kwargs = dict(
+        shots=int(args.shots),
+        mode="sync",
+        generate_amplitude=False,
+        quiet=True,
+        performance="custom",
+        threshold=int(args.threshold),
+        transfer_to_cpu=True,
+        max_threads=5,
+    )
+
+    print(f"[run] backend_id={backend_id} precision={args.precision} threshold={args.threshold} shots={args.shots}", flush=True)
+
+    # Timing + peak RSS sampler around run
+    running, th, peak = start_peak_rss_sampler(0.05)
+    t_submit = time.perf_counter()
+
+    job = backend.run(qc, **run_kwargs)
+    job_monitor(job, quiet=True)
+    result = job.result()
+
+    t_done = time.perf_counter()
+    stop_peak_rss_sampler(running, th)
+
+    run_wall_s = t_done - t_submit
+    peak_rss_bytes = int(peak["rss"])
+
+    # Counts top-K
+    counts = result.get_counts()
+    if not isinstance(counts, dict):
+        die(f"result.get_counts() returned unexpected type: {type(counts)}")
+
+    # normalize keys (strip spaces just in case)
+    counts_norm = {str(k).replace(" ", ""): int(v) for k, v in counts.items()}
+    total_shots_from_counts = sum(int(v) for v in counts_norm.values())
+
+    items = [(str(k), int(v)) for k, v in counts_norm.items()]
+    items.sort(key=lambda kv: (-kv[1], kv[0]))
+
+    topk = max(1, int(args.topk))
+    top_items = items[:topk]
+    top_sum = sum(c for _, c in top_items)
+    tail_mass = (total_shots_from_counts - top_sum) / total_shots_from_counts if total_shots_from_counts else 0.0
+
+    # QR12 SDK-native metrics (best-effort)
+    sdk_metrics: Dict[str, Any] = {"errors": {}}
+
+    bif, bif_err = safe_call_result_getter(result, "get_fidelity")
+    if bif_err:
+        sdk_metrics["errors"]["get_fidelity"] = bif_err
+    sdk_metrics["get_fidelity"] = jsonable_value(bif)
+
+    # get_peakmemorysize appears to require an experiment index in QR12 (arg0:int)
+    bipm = None
+    bipm_err = None
+    if hasattr(result, "get_peakmemorysize"):
+        try:
+            bipm = result.get_peakmemorysize(0)
+        except Exception as e0:
+            # fallback: some builds *might* accept no-arg
+            try:
+                bipm = result.get_peakmemorysize()
+            except Exception as e1:
+                bipm_err = repr(e1)
+                # optional: keep original error too
+                sdk_metrics["errors"]["get_peakmemorysize(0)"] = repr(e0)
+    else:
+        bipm_err = "missing"
+
+    if bipm_err:
+        sdk_metrics["errors"]["get_peakmemorysize_0"] = bipm_err
+
+    # store under an explicit name so we remember index=0 was used
+    sdk_metrics["get_peakmemorysize_0"] = jsonable_value(bipm)
+
+
+    memx, memx_err = safe_call_result_getter(result, "get_memory")
+    if memx_err:
+        sdk_metrics["errors"]["get_memory"] = memx_err
+    sdk_metrics["get_memory"] = jsonable_value(memx)
+
+    # If peakmemorysize looks numeric, also store a convenience conversion guess
+    try:
+        if isinstance(bipm, (int, float)) and float(bipm) > 0:
+            bipm_f = float(bipm)
+            # heuristic: if it looks like bytes, offer MB estimate too
+            sdk_metrics["get_peakmemorysize_mb_guess"] = bipm_f / (1024.0 * 1024.0) if bipm_f > 1024.0 * 1024.0 else bipm_f
+    except Exception:
+        pass
+
+    # Output path
+    if args.json_out:
+        out_path = args.json_out
+    else:
+        out_path = default_json_out(args.qasm, backend_id, args.precision, int(args.threshold), int(args.shots), args.out_dir)
+    os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
+
+    # System info (best-effort)
+    gpu_info = try_nvidia_smi()
+
+    payload: Dict[str, Any] = {
+        "meta": {
+            "created_utc": _dt.datetime.now(_dt.timezone.utc).replace(microsecond=0).isoformat(),
+            "qasm_file": os.path.basename(args.qasm),
+            "qasm_path": os.path.abspath(args.qasm),
+            "qasm_sha256": sha256_file(args.qasm),
+            "n_qubits": n_qubits,
+            "shots": int(args.shots),
+            "topk": topk,
+            "backend": str(args.backend),
+            "backend_id": backend_id,
+            "backend_repr": str(backend),
+            "precision": args.precision,
+            "threshold": int(args.threshold),
+            "sdk_pkg": sdk_pkg,
+            "sdk_version": sdk_ver,
+            "python_full": sys.version,
+        },
+        "sdk": {
+            **run_kwargs
+        },
+        "system": {
+            "hostname": platform.node(),
+            "platform": platform.platform(),
+            "python": sys.version.split()[0],
+            "cpu_count": os.cpu_count(),
+            "gpu": gpu_info,
+        },
+        "timing_s": {
+            "run_wall_s": float(run_wall_s),
+        },
+        "memory": {
+            "peak_rss_bytes": int(peak_rss_bytes),
+            "peak_rss_mb": float(peak_rss_bytes) / (1024.0 * 1024.0),
+        },
+        "sdk_metrics": sdk_metrics,
+        "hist": {
+            "unique_outcomes": len(items),
+            "total_shots": int(total_shots_from_counts),
+            "tail_mass": float(tail_mass),
+            "top": [{"bitstring": b, "count": c} for b, c in top_items],
+        },
+    }
+
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2, sort_keys=True)
+
+    print(f"[ok] wrote JSON: {out_path}", flush=True)
+    print(f"[result] unique_outcomes={len(items)} total_shots={total_shots_from_counts} tail_mass={tail_mass:.6f}", flush=True)
+    print(f"[timing] run_wall_s={run_wall_s:.3f}  [mem] peak_rss_mb={payload['memory']['peak_rss_mb']:.1f}", flush=True)
+    print(f"[sdk] get_fidelity={sdk_metrics.get('get_fidelity')} get_peakmemorysize_0={sdk_metrics.get('get_peakmemorysize_0')}", flush=True)
+    if sdk_metrics.get("errors"):
+        print(f"[sdk] errors={sdk_metrics['errors']}", flush=True)
+    print("===== done =====", flush=True)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except SystemExit:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        die(f"Unhandled exception: {e}")
+