simdref 0.0.14__tar.gz → 0.0.15__tar.gz

{simdref-0.0.14/src/simdref.egg-info → simdref-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simdref
-Version: 0.0.14
+Version: 0.0.15
 Summary: Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP.
 Author: Marco
 License: GPL-3.0-or-later

{simdref-0.0.14 → simdref-0.0.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simdref"
-version = "0.0.14"
+version = "0.0.15"
 description = "Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP."
 readme = "README.md"
 requires-python = ">=3.10"

{simdref-0.0.14 → simdref-0.0.15}/src/simdref/annotate.py

@@ -17,7 +17,7 @@ from enum import Enum
 from typing import Any, Iterable, Iterator
 
 from simdref import perf
-from simdref.lsp import identity_keys
+from simdref.lsp import NO_CATALOG_ROW, identity_keys
 from simdref.models import InstructionRecord
 from simdref.storage import load_instruction_from_db, load_instructions_by_mnemonic_from_db
 
@@ -460,7 +460,9 @@ class PerfSummary:
 def _per_arch_value(details: dict[str, Any], value_fn) -> float | None:
     for v in value_fn(details):
         try:
-            return float(v)
+            # Latency ranges render as "min-max" strings (simdref#50); the
+            # float view takes the min so aggregates stay numeric.
+            return float(str(v).split("-", 1)[0])
         except (TypeError, ValueError):
             continue
     return None
@@ -688,6 +690,24 @@ def _annotate_instruction(
     """Return the rendered output line and an optional JSON record."""
     if stats is not None:
         stats["parsed"] = stats.get("parsed", 0) + 1
+    if identity_key == NO_CATALOG_ROW:
+        # Byte identity identified the form and the catalog has no row for
+        # it (issue #49: uops.info carries no AVX reg-reg VMOVAPD/VMOVUPS):
+        # report the miss by name, never guess a neighbour form below.
+        if stats is not None:
+            stats["no_row"] = stats.get("no_row", 0) + 1
+        no_row: dict[str, Any] = {
+            "mnemonic": parsed.mnemonic,
+            "known": False,
+            "no_measured_row": True,
+        }
+        if parsed.address is not None:
+            no_row["address"] = f"0x{parsed.address:x}"
+        if parsed.source_file:
+            no_row["source_file"] = parsed.source_file
+        if parsed.source_line is not None:
+            no_row["source_line"] = parsed.source_line
+        return f"{parsed.raw}   # {parsed.mnemonic}: no measured row", no_row
     # Byte identity wins over the form pick: the record is what the line
     # assembles to, and an empty row keeps the old pick unchanged.
     record = load_instruction_from_db(conn, identity_key) if identity_key else None

{simdref-0.0.14 → simdref-0.0.15}/src/simdref/cli.py

@@ -1897,9 +1897,21 @@ def _build_llm_payload(
         }
     # Byte identity wins over the name lookups below: a full assembly line
     # resolves to the one row its bytes name.
-    from simdref.lsp import identity_keys
+    from simdref.lsp import NO_CATALOG_ROW, identity_keys
 
     keys = identity_keys([query_str], None, conn)
+    if keys[0] == NO_CATALOG_ROW:
+        # Identified form the catalog lacks (issue #49): report the miss by
+        # name, never join the line to a neighbour form's row.
+        mnemonic = query_str.split(None, 1)[0]
+        return {
+            "query": query_str,
+            "mode": "exact",
+            "match_kind": "instruction",
+            "detail": f"{mnemonic}: no measured row",
+            "results": [],
+            **meta,
+        }
     if keys[0]:
         item = load_instruction_from_db(conn, keys[0])
         if item is not None:

{simdref-0.0.14 → simdref-0.0.15}/src/simdref/lsp.py

@@ -963,6 +963,14 @@ def _document_arch(
     return name, ("intel" if syntax else "att"), keep
 
 
+# identity_keys slot value when byte identity ran on a schema-14 catalog and
+# identified the instruction, but the catalog has no row for that form. Not a
+# db_key: callers show the line as having no measured row and never fall back
+# to the legacy pick. The legacy pick stays only where byte identity could
+# not run (missing tools, a schema-13 catalog, a declined document).
+NO_CATALOG_ROW = "?:no-catalog-row"
+
+
 @functools.lru_cache(maxsize=32)
 def _identity_batch(
     texts: tuple[str, ...], intel: bool, syntax: bool, catalog: str, mtime_ns: int
@@ -989,22 +997,36 @@ def _identity_batch(
     for index, held, result in zip(probed, keep, results):
         # The text check keeps a row on its own line even if a text carries
         # its own line break.
-        if held and result.row is not None and result.text == texts[index]:
+        if not held or result.text != texts[index]:
+            continue
+        if result.row is not None:
             slots[index] = result.row.db_key
+        elif result.reason == "no catalog row" or result.reason.startswith(
+            ("no catalog row (iform ", "no catalog row (splits emptied ")
+        ):
+            # Byte identity identified the form and the catalog lacks its row
+            # (e.g. uops.info carries no AVX reg-reg VMOVAPD): mark the miss.
+            # A fixup placeholder or a foreign decode mode keeps the line on
+            # the old matcher: the row can exist, it is just not byte-proven.
+            slots[index] = NO_CATALOG_ROW
     return tuple(slots)
 
 
 def identity_keys(
     texts: Sequence[str], intel: bool | None, conn: sqlite3.Connection
 ) -> list[str | None]:
-    """Map each text to the catalog db_key its encoded bytes name, or None.
+    """Map each text to the catalog db_key its encoded bytes name, or a mark.
 
     One shared entry for hover, inlay hints, annotate and the llm query: one
     llvm-mc run per document batch, cached per document content. A None means
-    byte identity has no row there and the caller's old matcher answers that
-    line unchanged. ``intel`` is the file-type syntax flag; None infers the
-    x86 syntax from the text, and keeps the operand votes neutral so a bare
-    AArch64 or RISC-V line never reads as forced x86.
+    byte identity could not run for the line (tools missing, a schema-13
+    catalog, a document byte identity declined, or a line that votes another
+    arch) and the caller's old matcher answers that line unchanged.
+    NO_CATALOG_ROW means byte identity identified the instruction and the
+    catalog has no row for that form: the caller reports no measured row and
+    never guesses a neighbour form. ``intel`` is the file-type syntax flag;
+    None infers the x86 syntax from the text, and keeps the operand votes
+    neutral so a bare AArch64 or RISC-V line never reads as forced x86.
     """
     if not texts:
         return []
@@ -1079,6 +1101,10 @@ def _hover_markdown(
 
     if not allow_instruction:
         return None
+    if identity_key == NO_CATALOG_ROW:
+        # Byte identity identified the form and the catalog has no row for
+        # it: say so by name, never guess a neighbour form below.
+        return f"`{word}`: no measured row"
     # Byte identity wins over every matcher pick below: the row is what the
     # line assembles to. None keeps the old matcher on its exact-name path.
     instruction = load_instruction_from_db(conn, identity_key) if identity_key else None
@@ -1375,14 +1401,22 @@ def _inlay_hints(conn, text: str, language_id: str, uri: str, start: int, end: i
     semicolon_is_comment = _semicolon_is_comment(language_id, uri)
     candidates = _asm_candidates(text, language_id, uri)
     keys = identity_keys([segment for _line, segment in candidates], semicolon_is_comment, conn)
-    records = {key: load_instruction_from_db(conn, key) for key in set(keys) if key is not None}
+    records = {
+        key: load_instruction_from_db(conn, key)
+        for key in set(keys)
+        if key is not None and key != NO_CATALOG_ROW
+    }
     hints: dict[int, list[str]] = {}  # every instruction on the source line feeds its hint
     labels: dict[str, str | None] = {}  # one matcher run per distinct segment, not per line
     for (line, segment), key in zip(candidates, keys):
         if not start <= line <= end:
             continue
         record = records.get(key) if key else None
-        if record is not None:
+        if key == NO_CATALOG_ROW:
+            # Identified form the catalog lacks: name it, never the old pick.
+            parsed = _mnemonic_from_asm_line(segment, semicolon_is_comment)
+            label = f"{parsed[0]}: no measured row" if parsed else None
+        elif record is not None:
             label = _cut_label(record.summary or "")
         elif segment in labels:
             label = labels[segment]

{simdref-0.0.14 → simdref-0.0.15}/src/simdref/perf.py

@@ -62,8 +62,11 @@ def latency_cycle_values(latencies: list[dict[str, Any]]) -> list[str]:
     """Collect unique cycle-count strings from a list of latency dicts.
 
     Each *latency* dict may contain keys like ``cycles``, ``cycles_mem``,
-    ``cycles_addr``, or ``cycles_addr_index``.  Values are collected in
-    order, skipping duplicates.
+    ``cycles_addr``, or ``cycles_addr_index``. uops.info divide/sqrt
+    measurements carry a ``min_cycles`` / ``max_cycles`` pair instead (and
+    ``_mem`` / ``_addr`` / ``_addr_index`` variants); a pair renders as one
+    range string (``"13"`` when equal, ``"13-15"`` otherwise). Values are
+    collected in order, skipping duplicates.
 
     Returns:
         De-duplicated list of cycle-count strings (may be empty).
@@ -81,6 +84,23 @@ def latency_cycle_values(latencies: list[dict[str, Any]]) -> list[str]:
                 continue
             if value not in values:
                 values.append(value)
+        for suffix in ("", "_mem", "_addr", "_addr_index"):
+            low = latency.get("min_cycles" + suffix, "")
+            high = latency.get("max_cycles" + suffix, "")
+            if not low and not high:
+                continue
+            low_only = low or high
+            if (
+                suffix == "_mem"
+                and latency.get("min_cycles_mem_is_upper_bound") == "1"
+                and _is_numeric(low_only)
+                and float(low_only) == 0
+            ):
+                # Same not-measured convention as cycles_mem=0 above.
+                continue
+            value = f"{low}-{high}" if low and high and low != high else low_only
+            if value not in values:
+                values.append(value)
     return values
 
 

{simdref-0.0.14 → simdref-0.0.15/src/simdref.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simdref
-Version: 0.0.14
+Version: 0.0.15
 Summary: Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP.
 Author: Marco
 License: GPL-3.0-or-later

{simdref-0.0.14 → simdref-0.0.15}/src/simdref.egg-info/SOURCES.txt

@@ -73,6 +73,7 @@ tests/test_leftover_riscv_shared.py
 tests/test_lsp_stdio.py
 tests/test_lsp_web.py
 tests/test_models.py
+tests/test_no_catalog_row.py
 tests/test_pdfparse.py
 tests/test_perf.py
 tests/test_perf_sources.py

simdref-0.0.15/tests/test_no_catalog_row.py

@@ -0,0 +1,208 @@
+"""Issue #49: an identified form the catalog lacks reports no row.
+
+uops.info has no AVX register-register VMOVAPD/VMOVUPS rows, so byte identity
+correctly finds no row for ``vmovapd %xmm1, %xmm0``. Annotate, hover, hints
+and the llm query must say "no measured row" by name and never fall back to
+the legacy nearest-form pick (which joined the line to the store row, lat
+12c). The legacy pick stays only where byte identity could not run.
+
+Tool-dependent tests skip cleanly when llvm-mc or the XED decoder is absent;
+nothing fakes a pass.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+from test_asm_wire import _fail
+
+from simdref import annotate as annotate_mod
+from simdref import cli as cli_mod
+from simdref import lsp
+from simdref.asm_identity import _tool_path
+from simdref.lsp import NO_CATALOG_ROW, identity_keys
+from simdref.models import Catalog, InstructionRecord, SourceVersion
+from simdref.storage import build_sqlite, open_db
+
+LLVM_MC = _tool_path("SIMDREF_LLVM_MC", "llvm-mc") or ""
+XED = _tool_path("SIMDREF_XED", "xed") or ""
+needs_xed = pytest.mark.skipif(not (LLVM_MC and XED), reason="llvm-mc or xed absent")
+
+
+# A fixture catalog with only the store rows: the reg-reg iforms
+# (VMOVAPD_XMMdq_XMMdq_28, VMOVUPS_XMMdq_XMMdq_10) are absent, like the real
+# catalog. Measured SKL latency 12c mirrors the issue's wrong join.
+def _store_row(mnemonic: str, iform: str) -> InstructionRecord:
+    return InstructionRecord(
+        mnemonic=mnemonic,
+        form=f"{mnemonic} (M128, XMM)",
+        summary=f"Store via {mnemonic}.",
+        architecture="x86",
+        arch_details={
+            "SKL": {
+                "latencies": [{"cycles": "12"}],
+                "measurement": {"TP": "1.0"},
+                "source_kind": "measured",
+            }
+        },
+        metadata={"iform": iform, "split_attrs": "{}"},
+    )
+
+
+def _store_db(tmp_path):
+    rows = [
+        _store_row("VMOVAPD", "VMOVAPD_MEMdq_XMMdq"),
+        _store_row("VMOVUPS", "VMOVUPS_MEMdq_XMMdq"),
+    ]
+    db = tmp_path / "store-only.db"
+    build_sqlite(
+        Catalog(
+            intrinsics=[],
+            instructions=rows,
+            sources=[
+                SourceVersion(source="t", version="t", fetched_at="2025-01-01", url="test://")
+            ],
+            generated_at="2025-01-01",
+        ),
+        db,
+    )
+    return db
+
+
+REG_REG = ["vmovapd %xmm1, %xmm0", "vmovups %xmm3, %xmm2"]
+STORE = ["vmovapd %xmm0, (%rax)", "vmovups %xmm2, (%rsi)"]
+
+
+@needs_xed
+class TestNoCatalogRow:
+    def test_identity_marks_the_miss(self, tmp_path):
+        conn = open_db(path=_store_db(tmp_path))
+        try:
+            keys = identity_keys(REG_REG + STORE, False, conn)
+            store = [open_key for open_key in keys[2:]]
+        finally:
+            conn.close()
+        assert keys[:2] == [NO_CATALOG_ROW, NO_CATALOG_ROW]
+        assert all(key and key != NO_CATALOG_ROW for key in store)
+
+    def test_annotate_reports_no_row(self, tmp_path, monkeypatch):
+        conn = open_db(path=_store_db(tmp_path))
+        monkeypatch.setattr(annotate_mod, "lookup", _fail("the old lookup ran"))
+        try:
+            out = "".join(
+                annotate_mod.annotate_stream(
+                    [line + "\n" for line in REG_REG + STORE],
+                    opts=annotate_mod.AnnotateOptions(),
+                    conn=conn,
+                )
+            ).splitlines()
+        finally:
+            conn.close()
+        assert "# vmovapd: no measured row" in out[0]
+        assert "# vmovups: no measured row" in out[1]
+        for line in (out[0], out[1]):
+            assert "Store via" not in line
+            assert "lat=" not in line
+        # A store line still gets the store row.
+        assert "Store via VMOVAPD." in out[2]
+        assert "lat=12.0c" in out[2]
+        assert "Store via VMOVUPS." in out[3]
+
+    def test_annotate_json_marks_no_row(self, tmp_path, monkeypatch):
+        conn = open_db(path=_store_db(tmp_path))
+        monkeypatch.setattr(annotate_mod, "lookup", _fail("the old lookup ran"))
+        try:
+            out = "".join(
+                annotate_mod.annotate_stream(
+                    [REG_REG[0] + "\n", STORE[0] + "\n"],
+                    opts=annotate_mod.AnnotateOptions(fmt="json"),
+                    conn=conn,
+                )
+            )
+        finally:
+            conn.close()
+        records = json.loads(out)
+        assert records[0] == {
+            "mnemonic": "vmovapd",
+            "known": False,
+            "no_measured_row": True,
+        }
+        assert records[1]["known"] is True
+
+    def test_hover_reports_no_row(self, tmp_path, monkeypatch):
+        conn = open_db(path=_store_db(tmp_path))
+        monkeypatch.setattr(lsp, "_match_form", _fail("the old form matcher ran"))
+        monkeypatch.setattr(lsp, "_lookup_mnemonic", _fail("the old matcher ran"))
+        try:
+            key = identity_keys(REG_REG, False, conn)[0]
+            body = lsp._hover_markdown(conn, "vmovapd", identity_key=key)
+        finally:
+            conn.close()
+        assert body == "`vmovapd`: no measured row"
+
+    def test_hint_reports_no_row(self, tmp_path, monkeypatch):
+        conn = open_db(path=_store_db(tmp_path))
+        monkeypatch.setattr(lsp, "_hint_label", _fail("the old hint matcher ran"))
+        try:
+            hints = lsp._inlay_hints(
+                conn, REG_REG[0] + "\n" + STORE[0] + "\n", "asm", "file:///x.s", 0, 1
+            )
+        finally:
+            conn.close()
+        assert [hint["label"] for hint in hints] == [
+            "vmovapd: no measured row",
+            "Store via VMOVAPD.",
+        ]
+
+    def test_llm_reports_no_row(self, tmp_path, monkeypatch):
+        conn = open_db(path=_store_db(tmp_path))
+        monkeypatch.setattr(cli_mod, "_find_instructions_fast", _fail("the old name lookup ran"))
+        monkeypatch.setattr(cli_mod, "_search_runtime", _fail("the old search ran"))
+        try:
+            payload = cli_mod._build_llm_payload(conn, REG_REG[0], 8, None, None, None)
+        finally:
+            conn.close()
+        assert payload["mode"] == "exact"
+        assert payload["match_kind"] == "instruction"
+        assert payload["detail"] == "vmovapd: no measured row"
+        assert payload["results"] == []
+
+
+class TestMarkerPathNeedsNoTools:
+    def test_marker_never_calls_the_legacy_pick(self, tmp_path, monkeypatch):
+        # The marker reaches annotate even with tools absent; the old lookup
+        # must stay silent either way.
+        conn = open_db(path=_store_db(tmp_path))
+        monkeypatch.setattr(lsp, "_identity_batch", lambda *a, **k: (NO_CATALOG_ROW,))
+        monkeypatch.setattr(annotate_mod, "lookup", _fail("the old lookup ran"))
+        try:
+            out = "".join(
+                annotate_mod.annotate_stream(
+                    [REG_REG[0] + "\n"],
+                    opts=annotate_mod.AnnotateOptions(),
+                    conn=conn,
+                    stats={},
+                )
+            )
+        finally:
+            conn.close()
+        assert "# vmovapd: no measured row" in out
+
+    def test_no_marker_keeps_the_legacy_pick(self, tmp_path, monkeypatch):
+        # Byte identity could not run (None): the old matcher answers exactly
+        # as before the fix — here the issue's line with only the store row.
+        conn = open_db(path=_store_db(tmp_path))
+        monkeypatch.setattr(lsp, "_identity_batch", lambda *a, **k: (None,))
+        try:
+            out = "".join(
+                annotate_mod.annotate_stream(
+                    [REG_REG[0] + "\n"],
+                    opts=annotate_mod.AnnotateOptions(),
+                    conn=conn,
+                )
+            )
+        finally:
+            conn.close()
+        assert "no measured row" not in out
+        assert out.strip().startswith("vmovapd")

{simdref-0.0.14 → simdref-0.0.15}/tests/test_perf.py

@@ -68,6 +68,37 @@ class PerfTests(unittest.TestCase):
         latencies = [{"cycles_mem": "0"}]
         self.assertEqual(latency_cycle_values(latencies), ["0"])
 
+    def test_latency_cycle_values_reads_min_max_pair(self):
+        # simdref#50: uops.info divide/sqrt rows carry only a min/max range.
+        latencies = [
+            {"min_cycles": "13", "max_cycles": "15", "min_cycles_is_upper_bound": "1"},
+            {"min_cycles": "13", "max_cycles": "15", "min_cycles_is_upper_bound": "1"},
+        ]
+        self.assertEqual(latency_cycle_values(latencies), ["13-15"])
+
+    def test_latency_cycle_values_min_max_equal(self):
+        self.assertEqual(latency_cycle_values([{"min_cycles": "7", "max_cycles": "7"}]), ["7"])
+
+    def test_latency_cycle_values_min_only(self):
+        self.assertEqual(latency_cycle_values([{"min_cycles": "7"}]), ["7"])
+
+    def test_latency_cycle_values_drops_upper_bound_zero_mem_range(self):
+        latencies = [{"min_cycles_mem": "0", "min_cycles_mem_is_upper_bound": "1"}]
+        self.assertEqual(latency_cycle_values(latencies), [])
+
+    def test_min_max_pair_flows_to_every_output(self):
+        # simdref#50: the perf-root fix must reach every caller output: the
+        # string picks, the variant summary and the float annotate view.
+        from simdref.annotate import _latency_for, _per_arch_value
+
+        details = {"latencies": [{"min_cycles": "13", "max_cycles": "15"}]}
+        arch_details = {"MTL-P": details}
+        self.assertEqual(best_latency(arch_details), "13-15")
+        self.assertEqual(best_latency_labeled(arch_details).value, "13-15")
+        lat, _ = variant_perf_summary(arch_details)
+        self.assertEqual(lat, "13-15")
+        self.assertEqual(_per_arch_value(details, _latency_for), 13.0)
+
     def test_best_numeric_picks_smallest(self):
         self.assertEqual(best_numeric(["5", "3", "7"]), "3")
         self.assertEqual(best_numeric(["1.5", "2.0"]), "1.5")