simdref 0.0.0__py3-none-any.whl

simdref/web.py

@@ -0,0 +1,403 @@
+"""Static web-app export for simdref.
+
+Generates a self-contained single-page application (``index.html``) plus a
+two-tier data split:
+
+* **search-index.json** -- compact search data loaded at startup (~400 KB gzipped).
+* **detail-chunks/{PREFIX}.json** -- full instruction details (operands,
+  measurements) loaded on demand when the user selects a result.
+
+The HTML template is assembled from three source files under
+``simdref/templates/`` (HTML shell, CSS, JS) and inlined into a single
+``index.html``.
+"""
+
+from __future__ import annotations
+
+import gzip
+import json
+import re
+import shutil
+from collections import defaultdict
+from dataclasses import asdict
+from importlib import resources
+from pathlib import Path
+
+from simdref import __version__
+from simdref.filters import FilterSpec, CategorySpec
+from simdref.models import Catalog
+from simdref.display import (
+    display_architecture,
+    display_isa,
+    display_instruction_form,
+    isa_families,
+    isa_family,
+    isa_to_sub_isa,
+    strip_instruction_decorators,
+)
+from simdref.perf import best_numeric, latency_cycle_values, variant_perf_summary
+from simdref.pdfrefs import normalize_pdf_refs
+from simdref.storage import derive_arm_arch
+
+
+def _load_template() -> str:
+    """Assemble the HTML template from shell + CSS + JS source files."""
+    tpl = resources.files("simdref.templates")
+    html = tpl.joinpath("index.html").read_text()
+    css = tpl.joinpath("style.css").read_text()
+    js = tpl.joinpath("app.js").read_text()
+    return html.replace("/* __CSS__ */", css).replace("/* __JS__ */", js)
+
+
+def _latency_value(latencies: list[dict]) -> str:
+    """Best latency value from a list of latency dicts."""
+    return best_numeric(latency_cycle_values(latencies))
+
+
+def _web_measurements(item) -> list[dict]:
+    """Per-microarchitecture measurement rows for the web UI."""
+    rows: list[dict] = []
+    for uarch, details in item.arch_details.items():
+        measurement = details.get("measurement") or {}
+        if not measurement:
+            continue
+        rows.append({
+            "uarch": uarch,
+            "ports": measurement.get("ports", "-"),
+            "latency": _latency_value(details.get("latencies") or []),
+            "tpLoop": measurement.get("TP_loop") or measurement.get("TP") or "-",
+            "tpUnrolled": measurement.get("TP_unrolled", "-"),
+            "tpPorts": measurement.get("TP_ports", "-"),
+            "uops": measurement.get("uops", "-"),
+            "sourceKind": details.get("source_kind") or "measured",
+        })
+    return rows
+
+
+def _truncate(text: str, max_len: int = 120) -> str:
+    if len(text) <= max_len:
+        return text
+    return text[:max_len - 1] + "\u2026"
+
+
+def _chunk_prefix(mnemonic: str) -> str:
+    """3-char uppercase prefix for grouping instructions into chunks."""
+    clean = mnemonic.strip().upper()
+    return clean[:3] if len(clean) >= 3 else clean
+
+
+_INTRINSIC_PREFIX_STRIP = re.compile(r"^(?:mm\d*|sv|vq?)_?", re.IGNORECASE)
+_INTRINSIC_ALNUM = re.compile(r"[A-Za-z0-9]")
+
+
+def _intrinsic_chunk_prefix(name: str) -> str:
+    """3-char bucket key for grouping intrinsics by their op name.
+
+    Strips leading underscores, an optional ``riscv_`` namespace, and a
+    single width/family token (``mm``, ``mm256``, ``mm512``, ``sv``,
+    ``v``, ``vq``) so that buckets cluster by operation (``add``,
+    ``cvt``, ``fma``) rather than by vector width or platform. Without
+    the ``riscv_`` strip the 74k RISC-V vector intrinsics all fall into
+    a single 89 MB bucket.
+
+    Falls back to ``misc`` when a name does not produce at least two
+    alphanumeric characters after stripping.
+
+    The same function is re-implemented in ``app.js`` — keep in sync.
+    """
+    s = name.lstrip("_")
+    if s[:6].lower() == "riscv_":
+        s = s[6:]
+    m = _INTRINSIC_PREFIX_STRIP.match(s)
+    if m and m.end() < len(s):
+        s = s[m.end():]
+    s = s.lstrip("_")
+    clean = "".join(_INTRINSIC_ALNUM.findall(s)).lower()
+    if len(clean) < 2:
+        return "misc"
+    return clean[:3]
+
+
+def _intrinsic_search_fields(item) -> list[str]:
+    """Slim search-only field set: only what ranking/scoring actually needs."""
+    return [
+        item.name,
+        item.description or "",
+        display_isa(item.isa),
+        " ".join(item.instructions or []),
+    ]
+
+
+def _instruction_search_fields(item) -> list[str]:
+    display_key = display_instruction_form(item.key)
+    display_form = display_instruction_form(item.form)
+    return [
+        strip_instruction_decorators(item.mnemonic or ""),
+        display_key,
+        display_form,
+        item.summary or "",
+        display_isa(item.isa),
+    ]
+
+
+def _filter_spec_for_catalog(catalog: Catalog) -> FilterSpec:
+    spec = FilterSpec()
+    aggregate: dict[tuple[str, str, str], int] = {}
+    for item in catalog.intrinsics:
+        if not item.category:
+            continue
+        families = {isa_family(v) for v in (item.isa or [])} or {"Other"}
+        for family in families:
+            key = (family, item.category, item.subcategory or "")
+            aggregate[key] = aggregate.get(key, 0) + 1
+    for item in catalog.instructions:
+        cat = (item.metadata or {}).get("category", "") if isinstance(item.metadata, dict) else ""
+        if not cat:
+            continue
+        families = {isa_family(v) for v in (item.isa or [])} or {"Other"}
+        for family in families:
+            key = (family, cat, "")
+            aggregate[key] = aggregate.get(key, 0) + 1
+    spec.categories = [
+        CategorySpec(family=fam, category=cat, subcategory=sub, count=n)
+        for (fam, cat, sub), n in sorted(aggregate.items())
+    ]
+    return spec
+
+
+def _isa_config() -> dict:
+    """Legacy isa_config block embedded in ``search-index.json``."""
+    payload = FilterSpec().to_json()
+    payload.pop("categories", None)
+    return payload
+
+
+def _search_payload(catalog: Catalog) -> dict:
+    """Compact search-only payload for fast initial load."""
+    # Pre-compute perf summaries for instructions (keyed by instruction key).
+    instr_perf: dict[str, tuple[str, str]] = {}
+    for item in catalog.instructions:
+        lat, cpi = variant_perf_summary(item.arch_details)
+        instr_perf[item.db_key] = (lat, cpi)
+
+    def _intrinsic_perf(item) -> tuple[str, str]:
+        """Best lat/cpi from the primary linked instruction."""
+        for inst_ref in item.instruction_refs:
+            key = inst_ref.get("key", "")
+            if key in instr_perf:
+                return instr_perf[key]
+        return ("-", "-")
+
+    def _intrinsic_primary_instr(item) -> str:
+        for ref in item.instruction_refs or []:
+            key = ref.get("key") if isinstance(ref, dict) else None
+            if key:
+                return key
+        return (item.instructions or [""])[0]
+
+    intrinsics_out = []
+    for item in catalog.intrinsics:
+        lat, cpi = _intrinsic_perf(item)
+        fields = _intrinsic_search_fields(item)
+        entry: dict = {
+            "name": item.name,
+            "subtitle": _truncate(item.description or "", 80),
+            "architecture": item.architecture,
+            "isa": item.isa,
+            "lat": lat,
+            "cpi": cpi,
+            "display_architecture": display_architecture(item.architecture),
+            "display_isa": display_isa(item.isa),
+            "isa_families": isa_families(item.isa),
+            "isa_subs": list(dict.fromkeys(filter(None, (isa_to_sub_isa(value) for value in item.isa)))),
+            "search_fields": fields,
+        }
+        primary = _intrinsic_primary_instr(item)
+        if primary:
+            entry["primary_instr"] = primary
+        arm_arch = derive_arm_arch(item.isa, item.metadata if isinstance(item.metadata, dict) else {})
+        if arm_arch:
+            entry["arm_arch"] = arm_arch
+        category = (item.metadata or {}).get("category", "") if isinstance(item.metadata, dict) else ""
+        if category:
+            entry["category"] = category
+        intrinsics_out.append(entry)
+
+    instructions_out = []
+    for item in catalog.instructions:
+        lat, cpi = instr_perf[item.db_key]
+        fields = _instruction_search_fields(item)
+        instructions_out.append({
+            "key": item.db_key,
+            "mnemonic": item.mnemonic,
+            "form": item.form,
+            "architecture": item.architecture,
+            "summary": _truncate(item.summary or "", 80),
+            "isa": item.isa,
+            "linked_intrinsics": item.linked_intrinsics,
+            "lat": lat,
+            "cpi": cpi,
+            "display_architecture": display_architecture(item.architecture),
+            "display_key": display_instruction_form(item.key),
+            "display_form": display_instruction_form(item.form),
+            "display_mnemonic": strip_instruction_decorators(item.mnemonic),
+            "display_isa": display_isa(item.isa),
+            "isa_families": isa_families(item.isa),
+            "isa_subs": list(dict.fromkeys(filter(None, (isa_to_sub_isa(value) for value in item.isa)))),
+            "search_fields": fields,
+        })
+
+    return {
+        "generated_at": catalog.generated_at,
+        "sources": [asdict(source) for source in catalog.sources],
+        "isa_config": _isa_config(),
+        "intrinsics": intrinsics_out,
+        "instructions": instructions_out,
+    }
+
+
+def _detail_chunks(catalog: Catalog) -> dict[str, dict]:
+    """Group full instruction details by 3-char mnemonic prefix.
+
+    Returns a mapping of ``{prefix: {key: detail_dict}}``.
+    """
+    chunks: dict[str, dict] = defaultdict(dict)
+    for item in catalog.instructions:
+        prefix = _chunk_prefix(item.mnemonic)
+        chunks[prefix][item.db_key] = {
+            "mnemonic": item.mnemonic,
+            "form": item.form,
+            "architecture": item.architecture,
+            "display_architecture": display_architecture(item.architecture),
+            "display_form": display_instruction_form(item.form),
+            "display_mnemonic": strip_instruction_decorators(item.mnemonic),
+            "summary": item.summary,
+            "description": item.description,
+            "isa": item.isa,
+            "display_isa": display_isa(item.isa),
+            "operand_details": [
+                {
+                    "idx": op.get("idx", ""),
+                    "r": op.get("r", ""),
+                    "w": op.get("w", ""),
+                    "type": op.get("type", ""),
+                    "width": op.get("width", ""),
+                    "xtype": op.get("xtype", ""),
+                    "name": op.get("name", ""),
+                }
+                for op in item.operand_details
+            ],
+            "metadata": {
+                k: v for k, v in item.metadata.items()
+                if k in {"url", "url-ref", "category", "cpl", "intel-sdm-url", "intel-sdm-page-start", "intel-sdm-page-end"}
+            },
+            "pdf_refs": normalize_pdf_refs(item.pdf_refs, item.metadata),
+            "linked_intrinsics": item.linked_intrinsics,
+            "measurements": _web_measurements(item),
+        }
+    return dict(chunks)
+
+
+def _intrinsic_detail_entry(item) -> dict:
+    return {
+        "name": item.name,
+        "signature": item.signature,
+        "description": item.description,
+        "header": item.header,
+        "url": item.url,
+        "architecture": item.architecture,
+        "display_architecture": display_architecture(item.architecture),
+        "isa": item.isa,
+        "display_isa": display_isa(item.isa),
+        "display_isa_tokens": [display_isa([value]) for value in item.isa],
+        "instructions": item.instructions,
+        "instruction_refs": item.instruction_refs,
+        "metadata": item.metadata,
+        "doc_sections": item.doc_sections,
+        "notes": item.notes,
+    }
+
+
+def _intrinsic_chunks(catalog: Catalog) -> dict[str, dict]:
+    """Group full intrinsic details by bucket prefix.
+
+    Mirrors the ``detail-chunks/`` layout used for instructions so that
+    clicking an intrinsic only fetches the ~100-200 KB chunk containing
+    it rather than the ~138 MB full file.
+    """
+    chunks: dict[str, dict] = defaultdict(dict)
+    for item in catalog.intrinsics:
+        prefix = _intrinsic_chunk_prefix(item.name)
+        chunks[prefix][item.name] = _intrinsic_detail_entry(item)
+    return dict(chunks)
+
+
+def _build_stamp(catalog: Catalog) -> dict:
+    from datetime import datetime, timezone
+    import subprocess
+    git_sha = ""
+    try:
+        git_sha = subprocess.check_output(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=Path(__file__).resolve().parent,
+            text=True,
+            stderr=subprocess.DEVNULL,
+            timeout=2,
+        ).strip()
+    except (subprocess.SubprocessError, OSError):
+        git_sha = ""
+    return {
+        "version": __version__,
+        "git_sha": git_sha,
+        "catalog_generated_at": catalog.generated_at,
+        "intrinsics": len(catalog.intrinsics),
+        "instructions": len(catalog.instructions),
+        "built_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def export_web(catalog: Catalog, web_dir: Path) -> None:
+    """Write the web app to *web_dir*.
+
+    Outputs:
+    * ``index.html`` -- assembled SPA
+    * ``search-index.json`` -- compact search data
+    * ``filter_spec.json`` -- shared ISA/category facets (web + CLI)
+    * ``build_stamp.json`` -- version/freshness metadata
+    * ``detail-chunks/{PREFIX}.json`` -- instruction detail chunks
+    * ``intrinsic-chunks/{PREFIX}.json`` -- intrinsic detail chunks
+    """
+    web_dir.mkdir(parents=True, exist_ok=True)
+
+    def _write_json(path: Path, payload) -> None:
+        raw = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
+        path.write_bytes(raw)
+        with gzip.open(str(path) + ".gz", "wb", compresslevel=6) as fh:
+            fh.write(raw)
+
+    (web_dir / "index.html").write_text(_load_template())
+
+    _write_json(web_dir / "search-index.json", _search_payload(catalog))
+
+    filter_spec = _filter_spec_for_catalog(catalog)
+    _write_json(web_dir / "filter_spec.json", filter_spec.to_json())
+
+    _write_json(web_dir / "build_stamp.json", _build_stamp(catalog))
+
+    chunks_dir = web_dir / "detail-chunks"
+    if chunks_dir.exists():
+        shutil.rmtree(chunks_dir)
+    chunks_dir.mkdir()
+    for prefix, chunk in _detail_chunks(catalog).items():
+        _write_json(chunks_dir / f"{prefix}.json", chunk)
+
+    intrinsic_chunks_dir = web_dir / "intrinsic-chunks"
+    if intrinsic_chunks_dir.exists():
+        shutil.rmtree(intrinsic_chunks_dir)
+    intrinsic_chunks_dir.mkdir()
+    for prefix, chunk in _intrinsic_chunks(catalog).items():
+        _write_json(intrinsic_chunks_dir / f"{prefix}.json", chunk)
+
+    for stale in (web_dir / "intrinsic-details.json", web_dir / "intrinsic-details.json.gz"):
+        if stale.exists():
+            stale.unlink()

simdref-0.0.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: simdref
+Version: 0.0.0
+Summary: Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, LSP, and static web export.
+Author: Marco
+License: GPL-3.0-or-later
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: msgpack<2,>=1.0
+Requires-Dist: pdfplumber<1,>=0.11
+Requires-Dist: PyMuPDF<2,>=1.24
+Requires-Dist: PyYAML<7,>=6
+Requires-Dist: rapidfuzz<4,>=3.9
+Requires-Dist: rich<15,>=13
+Requires-Dist: textual<2,>=1.0
+Requires-Dist: typer<1,>=0.19
+Dynamic: license-file
+
+# simdref
+
+[![CI](https://github.com/DiamonDinoia/simdref/actions/workflows/ci.yml/badge.svg)](https://github.com/DiamonDinoia/simdref/actions/workflows/ci.yml)
+[![Pages](https://github.com/DiamonDinoia/simdref/actions/workflows/pages.yml/badge.svg)](https://github.com/DiamonDinoia/simdref/actions/workflows/pages.yml)
+[![TestPyPI](https://img.shields.io/pypi/v/simdref?pypiBaseUrl=https%3A%2F%2Ftest.pypi.org&label=TestPyPI)](https://test.pypi.org/project/simdref/)
+[![Python](https://img.shields.io/pypi/pyversions/simdref?pypiBaseUrl=https%3A%2F%2Ftest.pypi.org)](https://test.pypi.org/project/simdref/)
+
+A single searchable reference for SIMD intrinsics and instructions across
+**x86 (Intel + uops.info)**, **Arm (ACLE / AARCHMRS)**, and **RISC-V
+(RVV + unified-db)**. Runs as a CLI, a Textual TUI, an LSP server,
+generated manpages, a static web app, and a structured JSON interface
+for LLM skills.
+
+[Web App](https://diamondinoia.github.io/simdref/) ·
+[TestPyPI](https://test.pypi.org/project/simdref/) ·
+[GitHub](https://github.com/DiamonDinoia/simdref) ·
+[Contributing](CONTRIBUTING.md)
+
+<!-- Screenshots are hosted on the `docs-assets` branch so the main
+     branch stays lightweight to clone. -->
+<p align="center">
+  <img alt="simdref TUI" src="https://raw.githubusercontent.com/DiamonDinoia/simdref/docs-assets/img/tui.svg" width="720">
+  <br><em>Interactive TUI with ISA filters, ranked results, and measured/modeled performance tables.</em>
+</p>
+
+## Install
+
+```bash
+pip install simdref
+isa update     # download the pre-built catalog
+isa doctor     # confirm everything is wired up
+isa            # open the TUI
+```
+
+The package installs two equivalent executables, **`isa`** (short) and
+**`simdref`** (explicit). The rest of this README uses `isa`.
+
+`isa update` pulls the combined catalog (x86 measured + Arm/RISC-V
+measured & modeled) from the latest GitHub Release — **no `llvm-mca`
+required**. Only contributors doing a full local rebuild with
+`isa build` need `llvm-mca` 18+ on `PATH`.
+
+Pre-release builds live on TestPyPI:
+
+```bash
+pip install -i https://test.pypi.org/simple/ \
+            --extra-index-url https://pypi.org/simple/ simdref
+```
+
+## Quickstart
+
+```bash
+isa _mm_add_ps       # exact intrinsic  -> detailed view
+isa VPADDD           # exact instruction -> detailed view
+isa _mm_add          # fuzzy -> ranked search results
+isa mm add           # tokenized query -> intrinsic-biased search
+isa ADD              # mnemonic-like -> instruction-biased search
+isa VADDPS 2         # pick variant #2 from the last result list
+isa                  # open the interactive TUI
+```
+
+## Interfaces
+
+**Web app** — a self-contained static SPA with filters and performance
+tables, published to GitHub Pages at
+[diamondinoia.github.io/simdref](https://diamondinoia.github.io/simdref/).
+Export your own copy:
+
+```bash
+isa web --web-dir ./web
+isa serve --web-dir ./web       # gzip-aware local server
+```
+
+The [live demo](https://diamondinoia.github.io/simdref/) hosts the same
+build — search across ~122k entries with ISA filters and per-uarch perf
+tables.
+
+**LSP** — hover docs + completion for intrinsic names and instruction
+mnemonics in any LSP-capable editor:
+
+```bash
+simdref-lsp                      # speaks JSON-RPC over stdio
+```
+
+```lua
+-- Neovim
+vim.lsp.start({ name = "simdref", cmd = { ".venv/bin/simdref-lsp" } })
+```
+
+**LLM interface** — stable JSON / NDJSON for agents and editor skills,
+with meaningful exit codes so tools can distinguish *no match* (2),
+*ambiguous* (3), and *bad flag* (1):
+
+```bash
+isa llm query _mm_add_ps --source-kind measured
+echo -e "_mm_add_ps\nVPADDD" | isa llm batch
+isa llm list --pattern "*gather*" --isa Intel
+```
+
+See [docs/LLM.md](docs/LLM.md) for the full payload shape and a
+Claude-skill recipe.
+
+**Assembly annotator** — turn compiler output into a self-documented
+`.sa` file. Given `hello_simd.s`:
+
+```asm
+dot8:
+    vmovups (%rdi), %ymm0
+    vmovups (%rsi), %ymm1
+    vmulps  %ymm1, %ymm0, %ymm0
+    vaddps  %ymm0, %ymm0, %ymm0
+    vhaddps %ymm0, %ymm0, %ymm0
+    ret
+```
+
+```bash
+isa annotate hello_simd.s           # writes hello_simd.sa
+isa annotate hello_simd.s --arch skylake-x -o -   # to stdout, skylake-x only
+```
+
+produces:
+
+```asm
+dot8:
+    vmovups (%rdi), %ymm0   # Move Unaligned Packed Single Precision FP Values. | lat=10.3c cpi=0.78 [avg of 25 archs, measured]
+    vmovups (%rsi), %ymm1   # Move Unaligned Packed Single Precision FP Values. | lat=10.3c cpi=0.78 [avg of 25 archs, measured]
+    vmulps  %ymm1, %ymm0, %ymm0   # Multiply Packed Single Precision FP Values. | lat=3.8c cpi=0.54 [avg of 25 archs, measured]
+    vaddps  %ymm0, %ymm0, %ymm0   # Add Packed Single Precision FP Values.      | lat=3.1c cpi=0.58 [avg of 25 archs, measured]
+    vhaddps %ymm0, %ymm0, %ymm0   # Horizontal Add Packed Single Precision FP.  | lat=5.6c cpi=2.22 [avg of 25 archs, measured]
+    ret
+```
+
+The output is still valid assembly — comments start with `#`, so `as`
+and `ld` still consume it.
+
+## Commands
+
+`isa --help` groups commands into **Commands** (day-to-day) and
+**Dev commands** (rebuild / export / completion).
+
+**Commands**
+
+| Command | Description |
+|---------|-------------|
+| `isa` / `isa <query>` | Open the TUI, pre-filling the query when one is given |
+| `isa doctor` | Check the installation — pass/fail per component, non-zero exit on failure |
+| `isa update` | Download the pre-built release catalog (no `llvm-mca` required) |
+| `isa llm query <q>` | Strict lookup → JSON/NDJSON/Markdown (see [docs/LLM.md](docs/LLM.md)) |
+| `isa llm batch` | Resolve many queries from stdin in one invocation (NDJSON out) |
+| `isa llm list` | Dump the `FilterSpec` or stream matching catalog entries |
+| `isa llm schema` | Print the JSON schema for `llm` payloads |
+| `isa annotate <file.s>` | Annotate a `.s` assembly file with per-instruction summaries and latency/CPI — writes `<file>.sa` |
+
+**Dev commands**
+
+| Command | Description |
+|---------|-------------|
+| `isa build` | Full local rebuild from upstream sources, including Intel SDM parsing (`llvm-mca` 18+ required) |
+| `isa web` | Export the static web app under `web/` |
+| `isa serve` | Serve the exported web app locally (gzip-aware) |
+| `isa completion install [SHELL]` | Install shell completion into the user's profile |
+| `isa completion show [SHELL]` | Print the completion script for a shell |
+
+## Data sources
+
+| Source | What | Entries¹ |
+|--------|------|----------|
+| Intel Intrinsics Guide | Signatures, descriptions, ISA, categories | 7,146 intrinsics |
+| uops.info | Instructions, operands, latency, throughput, ports | 22,276 instructions |
+| Arm ACLE (NEON/SVE) | Intrinsic signatures and descriptions | 10,791 intrinsics |
+| Arm AARCHMRS (A64) | Base instruction forms and operand tables | live-only² |
+| riscv-rvv-intrinsic-doc | RVV intrinsics with deterministic instruction refs | 74,319 intrinsics |
+| RISC-V unified-db | RVV instruction forms, ISA tags, Description/Operation | 2,868 instructions |
+
+¹ Counts from the current vendored snapshot. See
+[`docs/coverage/summary.json`](docs/coverage/summary.json) for live
+parity against upstream and [`docs/SOURCES.md`](docs/SOURCES.md) for
+licenses and refresh cadence.
+
+² The full AARCHMRS A64 spec is only available via live fetch or by
+dropping the tarball under `vendor/arm/`.
+
+Every rendered latency / CPI is tagged `(measured, <core>)` or
+`(modeled, <core>)` so measured and modeled numbers never get silently
+mixed.
+
+### Scope caveats
+
+- Performance data is x86-only in v1.
+- RISC-V coverage is RVV-focused — not full scalar or privileged ISA.
+
+## Development
+
+```bash
+git clone https://github.com/DiamonDinoia/simdref.git
+cd simdref
+python3 -m venv .venv
+.venv/bin/pip install -e .
+.venv/bin/isa build          # requires llvm-mca 18+
+.venv/bin/python -m pytest tests/ -v
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the full dev flow
+(tests, adding a new source, build stages) and
+[ARCHITECTURE.md](ARCHITECTURE.md) for module layout.
+
+## License
+
+[GNU General Public License v3.0](LICENSE).

simdref-0.0.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+simdref/__init__.py,sha256=AKGa4KA4aQgfyQ1tmwAZ18REXz74KTFq038f9Zhurd8,74
+simdref/__main__.py,sha256=DH7e8WtEXN2HJM9BaZRLcdsaWXiU01AtnPMxaj4McXQ,88
+simdref/annotate.py,sha256=fD1XleB1dwXb72ZmK_MeBOQy1q_b2jWOP1BAeQ4LAOQ,13857
+simdref/arm_instructions.py,sha256=5pd6KyICSJ6dfUgDAdBg2WxgTLB5loZsWE9N79wZRhQ,15488
+simdref/cli.py,sha256=g06ST1nporfpIECIZOt65WdsnSN5GmF1IB3haIdman4,63266
+simdref/display.py,sha256=oxKkZxHEaYqHCG5wsh-fluGV3no52S88agtrEwllbto,35563
+simdref/filters.py,sha256=nN3wwrneQUOnuSiWGNoe-8g7WFfhWV5piDhql2sGIHo,12189
+simdref/ingest.py,sha256=_ClfCBEqRDkWBe1WQpTbzIFpsDduLhzA6GXbhW9CFwc,3532
+simdref/ingest_catalog.py,sha256=pv7P4sXg4wsiKkvtERz-Zi9PsQECKA0WLFn9G1TBBE8,52310
+simdref/ingest_pdf.py,sha256=rMqpWdeU6BK7Nqtj_t4dEAC1G56-4-j9_tR-twYyVG8,6696
+simdref/ingest_sources.py,sha256=7lrEIt-xEUWYNt0_B_QkaiN6XVLLWsx26-9Q2GBuDxE,22144
+simdref/lsp.py,sha256=ytC4IY2nvyLzMBO-JsV3w4Dllu3-mmI4jOnXAn40e5U,8005
+simdref/manpages.py,sha256=blBKC5f01FwG_Y9_cEA16h8uOK_MeoxnK5qCPfQoUjU,6659
+simdref/models.py,sha256=rDDjOVHwy4PiyjxyK8V1Hq3xqemS3AlQKHo1_-E9jh8,7951
+simdref/pdfrefs.py,sha256=I6p7XGIXyp1QLA5gwJ3-NKzAejgUhMX7TnKbtKJfKjA,3208
+simdref/perf.py,sha256=MB5r2mQIEGYvkladNsEz0dYO8AEAOBz8Lehx0kLXR9w,8084
+simdref/queries.py,sha256=54s-r6uWpMVttDpjlGqX4QT4OGIzclU16hALbJ5jgGA,7144
+simdref/riscv.py,sha256=i62HZbQKc89SuCLjlj9EY0_uxOZM28ml-lHwzddt82g,17080
+simdref/search.py,sha256=JF_hyA65YDHNYQ7rAEQ7ufZNcbLxWh25352nQZ7l-gM,10546
+simdref/storage.py,sha256=1twUElPj2sHYHqUyDRmkPQBsCBlCgF4qQ4y2fpHFnmE,18501
+simdref/tui.py,sha256=Tew6-RZ58-2DgR7QoZdXemCPXaE_Dp-Nbu70QzTCe_Y,92361
+simdref/web.py,sha256=ztnI6nImJSqcN3p7VPEQpnudcjCizoz4glPyb9U19_0,14851
+simdref/pdfparse/__init__.py,sha256=P_25a2FQkjTB1xAjMCbfEyIq34qN4P8qOMe-cs5GA7w,419
+simdref/pdfparse/base.py,sha256=ODgZjrrDUyFhh_4LH6IQMLO5FarGovK38don1VB2Aog,4357
+simdref/pdfparse/intel.py,sha256=3-1vKISBs0VQvfXRIBfufd5BntVFTHt-jc4DsLQtRJU,23270
+simdref/pdfparse/registry.py,sha256=xbotrCuwN2in6W1xalJXPETmJ2TzatTIr7uBkZcO_lw,439
+simdref/pdfparse/types.py,sha256=S7U8uyRKKqHgO0x3mpi4hmrBKOIc-zIxC9vwOIc7CwM,2727
+simdref/perf_sources/__init__.py,sha256=kDYVXv_uNiZ9P2srZrp4cE8XgqeXWns5Di8Ph52D-dY,1555
+simdref/perf_sources/cores.py,sha256=XfKdxPvuM-M4C35YLILuFEo6aBeFK8bPzn9swMVLNMY,4804
+simdref/perf_sources/llvm_mca.py,sha256=YYhIWPEMMnOSc0lIJtRZdgn8rpSNoVDjOofrV494iPM,6577
+simdref/perf_sources/llvm_scheduling.py,sha256=cAS79SqFO9E_54osdt4p1U_7NpHfEzhvFza0JJMoKg8,23182
+simdref/perf_sources/merge.py,sha256=2rJf8PeAwFVzyRcEkkZXllKdQ0vgQ-Ww3U9-sEsAqYw,4183
+simdref/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simdref/templates/app.js,sha256=faU1joYcu23-sAzujeEwesyzrxqTrrmW3nqs7fLWUCs,66448
+simdref/templates/favicon.svg,sha256=3G9onI-56E0vT0iGGEMww0k7JNJsF_aKekMFhPT9DcA,319
+simdref/templates/index.html,sha256=WcCbsnP49uVZYd5xboSJGMYEId9K63I1b-Rdz0xNASE,5939
+simdref/templates/logo.svg,sha256=Q4t4v_F2DRgCHEcOsSGWz8VO8_5dCieLrwB1mDnb-8Q,1111
+simdref/templates/style.css,sha256=14gP2IbCRQ3Z2621Gv1y0sX3Ci1csfb0I5aE9rWxC9I,15952
+simdref-0.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+simdref-0.0.0.dist-info/METADATA,sha256=a6QoPzp78Z9VTY1Q1bsjs0DzpLRW65W97IEPS0NXKyQ,9234
+simdref-0.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simdref-0.0.0.dist-info/entry_points.txt,sha256=CS3tB1z18jjiCWTh-F73pN2lKUCmLOCMWzbaiADP6og,99
+simdref-0.0.0.dist-info/top_level.txt,sha256=eU7qjsZlLukdRacjuNm6ahYiuMKjE4G_LoWMqsJZmqU,8
+simdref-0.0.0.dist-info/RECORD,,