René's URL Explorer Experiment

{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"Non-externed Cython type definitions cause redefinition errors with transitive header includes","articleBody":"## Summary\n\nSeveral `cuda.bindings` Cython interfaces (`cynvvm`, `cynvml`, `cynvjitlink`, `cynvfatbin`) define types using Cython's quoted C name syntax without `cdef extern from` blocks. This causes C compilation errors when a user `cimport`s these types in a module that also transitively includes the corresponding C header.\n\n## Problem\n\nThe externed interfaces (`cynvrtc`, `cydriver`, `cyruntime`) use `cdef extern from \"header.h\"` blocks, so Cython emits a `#include` directive and the header's include guards prevent duplicate definitions.\n\nThe non-externed interfaces instead define types inline:\n\n```cython\n# cynvvm.pxd (current)\nctypedef enum nvvmResult \"nvvmResult\":\n    NVVM_SUCCESS \"NVVM_SUCCESS\" = 0\n    NVVM_ERROR_OUT_OF_MEMORY \"NVVM_ERROR_OUT_OF_MEMORY\" = 1\n    ...\n```\n\nWhen Cython compiles a `.pyx` that `cimport`s these types, it generates its own enum/typedef definitions in the C output. If any `cdef extern from` block in the same module (directly or via its `.pxd`) includes a header that transitively includes `nvvm.h`, the C compiler sees duplicate enum constant definitions and fails.\n\n## Minimal Reproducer\n\n**`nvvm.h`** (or the real one from the CUDA Toolkit):\n```c\n#ifndef NVVM_H\n#define NVVM_H\n\ntypedef enum {\n    NVVM_SUCCESS = 0,\n    NVVM_ERROR_OUT_OF_MEMORY = 1,\n    NVVM_ERROR_PROGRAM_CREATION_FAILURE = 2,\n    NVVM_ERROR_INVALID_INPUT = 4,\n    NVVM_ERROR_INVALID_PROGRAM = 5,\n} nvvmResult;\n\ntypedef void *nvvmProgram;\n\n#endif\n```\n\n**`example.h`** — a user header that happens to transitively include `nvvm.h`:\n```c\n#ifndef EXAMPLE_H\n#define EXAMPLE_H\n\n#include \"nvvm.h\"\n\nint test_func(int a);\n\n#endif\n```\n\n**`example.pxd`** — declares the user's C function:\n```cython\ncdef extern from \"example.h\":\n    int test_func(int a)\n```\n\n**`example.pyx`** — cimports the nvvm types from cuda.bindings:\n```cython\nfrom cuda.bindings.cynvvm cimport nvvmResult\n\ndef call_test(int x):\n    return test_func(x)\n```\n\n### Build Output\n\n```\nexample.c:1541:3: error: redeclaration of enumerator 'NVVM_SUCCESS'\n 1541 |   NVVM_SUCCESS = 0,\n      |   ^~~~~~~~~~~~\nIn file included from example.h:4,\n                 from example.c:1138:\nnvvm.h:5:5: note: previous definition of 'NVVM_SUCCESS' with type 'enum \u003canonymous>'\n    5 |     NVVM_SUCCESS = 0,\n      |     ^~~~~~~~~~~~\nexample.c:1542:3: error: redeclaration of enumerator 'NVVM_ERROR_OUT_OF_MEMORY'\n...\nexample.c:1547:25: error: conflicting types for 'nvvmResult'; have 'enum nvvmResult'\n```\n\nThe generated C file first emits `#include \"example.h\"` (which transitively includes `nvvm.h`), then later emits Cython's own `enum nvvmResult { NVVM_SUCCESS = 0, ... }` from the `cimport`. The duplicate enum constants are a hard C compilation error.\n\n## Impact\n\nAny downstream Cython project that wants to:\n1. Use types from `cynvvm`, `cynvml`, `cynvjitlink`, or `cynvfatbin` via `cimport`, **and**\n2. Has any `cdef extern from` that transitively includes the corresponding C header\n\n...will fail to compile. The user doesn't need to redeclare any types themselves — the mere transitive include is sufficient.\n\nThis does **not** affect the externed interfaces (`cynvrtc`, `cydriver`, `cyruntime`) since they use `cdef extern from`, which emits `#include` directives that are deduplicated by include guards.\n\n## Affected Interfaces\n\n| Interface | Style | Affected |\n|-----------|-------|----------|\n| `cynvvm.pxd` | Non-externed (quoted names) | Yes |\n| `cynvml.pxd` | Non-externed (quoted names) | Yes |\n| `cynvjitlink.pxd` | Non-externed (quoted names) | Yes |\n| `cynvfatbin.pxd` | Non-externed (quoted names) | Yes |\n| `cynvrtc.pxd` | `cdef extern from \"nvrtc.h\"` | No |\n| `cydriver.pxd` | `cdef extern from \"cuda.h\"` | No |\n| `cyruntime.pxd` | `cdef extern from \"driver_types.h\"` | No |\n\n## Suggested Fix\n\nSwitch the non-externed interfaces to use `cdef extern from` blocks, consistent with `cynvrtc.pxd`, `cydriver.pxd`, and `cyruntime.pxd`. This causes Cython to emit `#include` directives instead of generating its own type definitions, allowing include guards to deduplicate.\n\n**Edit:** On further analysis, this is **not** believed to be an ABI break. The `.pxd` file is purely a compile-time artifact — it is not referenced at runtime by already-compiled extensions. Since the quoted C names already produce the exact same C type identifiers and enum constant values as the header, the generated machine code is identical regardless of declaration style. Already-compiled downstream extensions would continue to work without recompilation against an updated `cuda.bindings` that makes this change.\n","author":{"url":"https://github.com/kkraus14","@type":"Person","name":"kkraus14"},"datePublished":"2026-02-19T22:57:24Z","url":"https://github.com/NVIDIA/cuda-python/issues/1663"}