fix(test): import SUPPORTED_TARGETS directly instead of parsing pyx

Drop the elaborate tokenize+AST walk that the cross-check test was
using to extract `SUPPORTED_TARGETS` from the pyx source. Drop the
`cdef` qualifier on the dict in `_program.pyx` (it gated Python
visibility -- removing it gives the test a direct import) and rewrite
the test as a plain comparison: import both views, check that NVRTC /
NVVM line up with their code-type counterparts and that the two linker
backends (nvJitLink, driver) match the ptx entry.

Performance impact of dropping `cdef` is one Python-level dict
`.get` per `Program.compile` call, which is negligible against the
NVRTC/linker work that follows.

Author: cpcloud

cuda_core/cuda/core/_program.pyx

@@ -1035,8 +1035,11 @@ cdef object Program_compile_nvvm(Program self, str target_type, object logs):
 
         return ObjectCode._init(bytes(data), target_type, name=self._options.name)
 
-# Supported target types per backend
-cdef dict SUPPORTED_TARGETS = {
+# Supported target types per backend. Plain Python-level binding (not
+# ``cdef``) so the cache layer's cross-check test can import it directly
+# instead of parsing this source file. Lookup performance inside
+# ``Program_compile`` is unaffected -- it's one dict ``.get`` per compile.
+SUPPORTED_TARGETS = {
     CompilerBackendType.NVRTC: (ObjectCodeFormatType.PTX, ObjectCodeFormatType.CUBIN, ObjectCodeFormatType.LTOIR),
     CompilerBackendType.NVVM: (ObjectCodeFormatType.PTX, ObjectCodeFormatType.LTOIR),
     CompilerBackendType.NVJITLINK: (ObjectCodeFormatType.CUBIN, ObjectCodeFormatType.PTX),

cuda_core/tests/test_program_cache.py

@@ -343,56 +343,20 @@ def test_make_program_cache_key_rejects(kwargs, exc_type, match):
 
 def test_make_program_cache_key_supported_targets_matches_program_compile():
     """``_SUPPORTED_TARGETS_BY_CODE_TYPE`` duplicates the backend target
-    matrix in ``_program.pyx``. Guard against drift: parse the pyx source
-    with :mod:`tokenize` (which skips string literals and comments) to
-    extract ``SUPPORTED_TARGETS`` and assert the two views agree."""
-    import ast
-    import io
-    import tokenize
-    from pathlib import Path
-
+    matrix in ``_program.pyx``. Import the pyx-side dict directly and
+    compare; both linker backends (nvJitLink, cuLink/driver) must agree
+    with the ``"ptx"`` code-type entry on the cache side."""
+    from cuda.core._program import SUPPORTED_TARGETS
+    from cuda.core.typing import CompilerBackendType
     from cuda.core.utils._program_cache._keys import _SUPPORTED_TARGETS_BY_CODE_TYPE
 
-    backend_to_code_type = {"NVRTC": "c++", "NVVM": "nvvm"}
-    linker_backends = ("nvJitLink", "driver")
-
-    pyx = Path(__file__).parent.parent / "cuda" / "core" / "_program.pyx"
-    text = pyx.read_text()
-    marker_idx = text.index("cdef dict SUPPORTED_TARGETS")
-    tokens = tokenize.generate_tokens(io.StringIO(text[marker_idx:]).readline)
-
-    depth = 0
-    start_offset = None
-    end_offset = None
-    lines = text[marker_idx:].splitlines(keepends=True)
-    line_starts = [0]
-    for line in lines[:-1]:
-        line_starts.append(line_starts[-1] + len(line))
-
-    def _offset(row, col):
-        return line_starts[row - 1] + col
-
-    for tok in tokens:
-        if tok.type != tokenize.OP:
-            continue
-        if tok.string == "{":
-            if depth == 0:
-                start_offset = _offset(tok.start[0], tok.start[1])
-            depth += 1
-        elif tok.string == "}":
-            depth -= 1
-            if depth == 0:
-                end_offset = _offset(tok.end[0], tok.end[1])
-                break
-    assert start_offset is not None and end_offset is not None, "could not locate SUPPORTED_TARGETS literal"
-    pyx_targets = ast.literal_eval(text[marker_idx + start_offset : marker_idx + end_offset])
+    backend_to_code_type = {CompilerBackendType.NVRTC: "c++", CompilerBackendType.NVVM: "nvvm"}
+    linker_backends = (CompilerBackendType.NVJITLINK, CompilerBackendType.DRIVER)
 
     for backend, code_type in backend_to_code_type.items():
-        assert frozenset(pyx_targets[backend]) == _SUPPORTED_TARGETS_BY_CODE_TYPE[code_type], (
-            backend,
-            code_type,
-        )
-    linker_sets = [frozenset(pyx_targets[b]) for b in linker_backends]
+        pyx_set = frozenset(str(t) for t in SUPPORTED_TARGETS[backend])
+        assert pyx_set == _SUPPORTED_TARGETS_BY_CODE_TYPE[code_type], (backend, code_type)
+    linker_sets = [frozenset(str(t) for t in SUPPORTED_TARGETS[b]) for b in linker_backends]
     assert all(s == linker_sets[0] for s in linker_sets)
     assert linker_sets[0] == _SUPPORTED_TARGETS_BY_CODE_TYPE["ptx"]